# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# 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):
        object.__setattr__(self, 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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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__(charp 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, value):
        """assign(charp self, char value)"""
        return _coin.charp_assign(self, value)


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


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


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

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

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

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__(intp 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, value):
        """assign(intp self, int value)"""
        return _coin.intp_assign(self, value)


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


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


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

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

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

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__(longp 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, value):
        """assign(longp self, long value)"""
        return _coin.longp_assign(self, value)


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


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


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

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

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

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__(floatp 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, value):
        """assign(floatp self, float value)"""
        return _coin.floatp_assign(self, value)


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


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


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

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

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

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__(doublep 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, value):
        """assign(doublep self, double value)"""
        return _coin.doublep_assign(self, value)


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


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


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

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

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


_coin.FALSE_swigconstant(_coin)
FALSE = _coin.FALSE

_coin.TRUE_swigconstant(_coin)
TRUE = _coin.TRUE

_coin.HAVE_INTTYPES_H_swigconstant(_coin)
HAVE_INTTYPES_H = _coin.HAVE_INTTYPES_H

_coin.HAVE_STDINT_H_swigconstant(_coin)
HAVE_STDINT_H = _coin.HAVE_STDINT_H

_coin.HAVE_SYS_TYPES_H_swigconstant(_coin)
HAVE_SYS_TYPES_H = _coin.HAVE_SYS_TYPES_H

_coin.HAVE_STDDEF_H_swigconstant(_coin)
HAVE_STDDEF_H = _coin.HAVE_STDDEF_H

_coin.HAVE_INT8_T_swigconstant(_coin)
HAVE_INT8_T = _coin.HAVE_INT8_T

_coin.HAVE_UINT8_T_swigconstant(_coin)
HAVE_UINT8_T = _coin.HAVE_UINT8_T

_coin.HAVE_INT16_T_swigconstant(_coin)
HAVE_INT16_T = _coin.HAVE_INT16_T

_coin.HAVE_UINT16_T_swigconstant(_coin)
HAVE_UINT16_T = _coin.HAVE_UINT16_T

_coin.HAVE_INT32_T_swigconstant(_coin)
HAVE_INT32_T = _coin.HAVE_INT32_T

_coin.HAVE_UINT32_T_swigconstant(_coin)
HAVE_UINT32_T = _coin.HAVE_UINT32_T

_coin.HAVE_INT64_T_swigconstant(_coin)
HAVE_INT64_T = _coin.HAVE_INT64_T

_coin.HAVE_UINT64_T_swigconstant(_coin)
HAVE_UINT64_T = _coin.HAVE_UINT64_T

_coin.HAVE_INTPTR_T_swigconstant(_coin)
HAVE_INTPTR_T = _coin.HAVE_INTPTR_T

_coin.HAVE_UINTPTR_T_swigconstant(_coin)
HAVE_UINTPTR_T = _coin.HAVE_UINTPTR_T

_coin.M_E_swigconstant(_coin)
M_E = _coin.M_E

_coin.M_LOG2E_swigconstant(_coin)
M_LOG2E = _coin.M_LOG2E

_coin.M_LOG10E_swigconstant(_coin)
M_LOG10E = _coin.M_LOG10E

_coin.M_LN2_swigconstant(_coin)
M_LN2 = _coin.M_LN2

_coin.M_LN10_swigconstant(_coin)
M_LN10 = _coin.M_LN10

_coin.M_PI_swigconstant(_coin)
M_PI = _coin.M_PI

_coin.M_TWOPI_swigconstant(_coin)
M_TWOPI = _coin.M_TWOPI

_coin.M_PI_2_swigconstant(_coin)
M_PI_2 = _coin.M_PI_2

_coin.M_PI_4_swigconstant(_coin)
M_PI_4 = _coin.M_PI_4

_coin.M_3PI_4_swigconstant(_coin)
M_3PI_4 = _coin.M_3PI_4

_coin.M_SQRTPI_swigconstant(_coin)
M_SQRTPI = _coin.M_SQRTPI

_coin.M_1_PI_swigconstant(_coin)
M_1_PI = _coin.M_1_PI

_coin.M_2_PI_swigconstant(_coin)
M_2_PI = _coin.M_2_PI

_coin.M_2_SQRTPI_swigconstant(_coin)
M_2_SQRTPI = _coin.M_2_SQRTPI

_coin.M_SQRT2_swigconstant(_coin)
M_SQRT2 = _coin.M_SQRT2

_coin.M_SQRT1_2_swigconstant(_coin)
M_SQRT1_2 = _coin.M_SQRT1_2

_coin.M_LN2LO_swigconstant(_coin)
M_LN2LO = _coin.M_LN2LO

_coin.M_LN2HI_swigconstant(_coin)
M_LN2HI = _coin.M_LN2HI

_coin.M_SQRT3_swigconstant(_coin)
M_SQRT3 = _coin.M_SQRT3

_coin.M_IVLN10_swigconstant(_coin)
M_IVLN10 = _coin.M_IVLN10

_coin.M_LOG2_E_swigconstant(_coin)
M_LOG2_E = _coin.M_LOG2_E

_coin.M_INVLN2_swigconstant(_coin)
M_INVLN2 = _coin.M_INVLN2

_coin.COIN_MAJOR_VERSION_swigconstant(_coin)
COIN_MAJOR_VERSION = _coin.COIN_MAJOR_VERSION

_coin.COIN_MINOR_VERSION_swigconstant(_coin)
COIN_MINOR_VERSION = _coin.COIN_MINOR_VERSION

_coin.COIN_MICRO_VERSION_swigconstant(_coin)
COIN_MICRO_VERSION = _coin.COIN_MICRO_VERSION

_coin.COIN_VERSION_swigconstant(_coin)
COIN_VERSION = _coin.COIN_VERSION

_coin.HAVE_HASH_QUOTING_swigconstant(_coin)
HAVE_HASH_QUOTING = _coin.HAVE_HASH_QUOTING

_coin.SUN_CC_4_0_SOTYPE_INIT_BUG_swigconstant(_coin)
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__(SbDict self, int const entries=251) -> SbDict
        __init__(SbDict self) -> SbDict
        __init__(SbDict self, SbDict arg2) -> 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(SbDict self, SbDictApplyFunc * rtn)
        applyToAll(SbDict self, SbDictApplyDataFunc * rtn, void * data)
        """
        return _coin.SbDict_applyToAll(self, *args)


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


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


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


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


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


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

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(name):
        """fromName(SbName name) -> SoType"""
        return _coin.SoType_fromName(name)

    fromName = staticmethod(fromName)

    def getName(self):
        """getName(SoType self) -> SbName"""
        return _coin.SoType_getName(self)


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


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


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

    getAllDerivedFrom = staticmethod(getAllDerivedFrom)

    def canCreateInstance(self):
        """canCreateInstance(SoType self) -> SbBool"""
        return _coin.SoType_canCreateInstance(self)


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


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


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


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


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


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


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


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


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

    removeType = staticmethod(removeType)

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

    init = staticmethod(init)

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

    fromKey = staticmethod(fromKey)

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

    badType = staticmethod(badType)

    def isBad(self):
        """isBad(SoType self) -> SbBool"""
        return _coin.SoType_isBad(self)


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


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


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

    getNumTypes = staticmethod(getNumTypes)

    def getInstantiationMethod(self):
        """getInstantiationMethod(SoType self) -> SoType::instantiationMethod"""
        return _coin.SoType_getInstantiationMethod(self)


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


    def __init__(self):
        """__init__(SoType 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(name):
    """SoType_fromName(SbName name) -> SoType"""
    return _coin.SoType_fromName(name)

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

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

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

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

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__(SbPList self, int const sizehint) -> SbPList
        __init__(SbPList self) -> SbPList
        __init__(SbPList 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, l):
        """copy(SbPList self, SbPList l)"""
        return _coin.SbPList_copy(self, l)


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


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


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


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


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


    def remove(self, index):
        """remove(SbPList self, int const index)"""
        return _coin.SbPList_remove(self, index)


    def removeFast(self, index):
        """removeFast(SbPList self, int const index)"""
        return _coin.SbPList_removeFast(self, index)


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


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


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


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


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


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


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


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


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


    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__(SbIntList self) -> SbIntList
        __init__(SbIntList self, int const sizehint) -> SbIntList
        """
        this = _coin.new_SbIntList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def append(self, item):
        """append(SbIntList self, int const item)"""
        return _coin.SbIntList_append(self, item)


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


    def insert(self, item, addbefore):
        """insert(SbIntList self, int const item, int const addbefore)"""
        return _coin.SbIntList_insert(self, item, addbefore)


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


    def __getitem__(self, i):
        """__getitem__(SbIntList self, int const i) -> int &"""
        return _coin.SbIntList___getitem__(self, i)


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

    __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__(SbString self) -> SbString
        __init__(SbString self, char const * s) -> SbString
        __init__(SbString self, char const * s, int start, int end) -> SbString
        __init__(SbString self, SbString s) -> SbString
        __init__(SbString self, int const 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 const * s) -> uint32_t
        """
        return _coin.SbString_hash(*args)

    hash = staticmethod(hash)

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


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


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


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


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


    def addIntString(self, value):
        """addIntString(SbString self, int const value)"""
        return _coin.SbString_addIntString(self, value)


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


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


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


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


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


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


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


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


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


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


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


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


    def __repr__(self):
        """__repr__(SbString self) -> char const *"""
        return _coin.SbString___repr__(self)

SbString_swigregister = _coin.SbString_swigregister
SbString_swigregister(SbString)

def SbString_hash(*args):
    """
    hash() -> uint32_t
    SbString_hash(char const * 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__(SbName self) -> SbName
        __init__(SbName self, char const * namestring) -> SbName
        __init__(SbName self, SbString str) -> SbName
        __init__(SbName 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(SbName self) -> char const *"""
        return _coin.SbName_getString(self)


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


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

    isIdentStartChar = staticmethod(isIdentStartChar)

    def isIdentChar(c):
        """isIdentChar(char const c) -> SbBool"""
        return _coin.SbName_isIdentChar(c)

    isIdentChar = staticmethod(isIdentChar)

    def isBaseNameStartChar(c):
        """isBaseNameStartChar(char const c) -> SbBool"""
        return _coin.SbName_isBaseNameStartChar(c)

    isBaseNameStartChar = staticmethod(isBaseNameStartChar)

    def isBaseNameChar(c):
        """isBaseNameChar(char const c) -> SbBool"""
        return _coin.SbName_isBaseNameChar(c)

    isBaseNameChar = staticmethod(isBaseNameChar)

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

    empty = staticmethod(empty)

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


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


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


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


    def __repr__(self):
        """__repr__(SbName self) -> char const *"""
        return _coin.SbName___repr__(self)

SbName_swigregister = _coin.SbName_swigregister
SbName_swigregister(SbName)

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

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

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

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

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__(SoError 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(func, data):
        """setHandlerCallback(SoErrorCB *const func, void *const data)"""
        return _coin.SoError_setHandlerCallback(func, data)

    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(SoError self) -> SbString"""
        return _coin.SoError_getDebugString(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

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


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


    def post(format):
        """post(char const *const format)"""
        return _coin.SoError_post(format)

    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(func, data):
    """SoError_setHandlerCallback(SoErrorCB *const func, void *const data)"""
    return _coin.SoError_setHandlerCallback(func, data)

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(format):
    """SoError_post(char const *const format)"""
    return _coin.SoError_post(format)

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(function, data):
        """setHandlerCallback(SoErrorCB *const function, void *const data)"""
        return _coin.SoDebugError_setHandlerCallback(function, data)

    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(SoDebugError self) -> SoType"""
        return _coin.SoDebugError_getTypeId(self)


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


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

    post = staticmethod(post)

    def postWarning(source, format):
        """postWarning(char const *const source, char const *const format)"""
        return _coin.SoDebugError_postWarning(source, format)

    postWarning = staticmethod(postWarning)

    def postInfo(source, format):
        """postInfo(char const *const source, char const *const format)"""
        return _coin.SoDebugError_postInfo(source, format)

    postInfo = staticmethod(postInfo)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoDebugError 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(function, data):
    """SoDebugError_setHandlerCallback(SoErrorCB *const function, void *const data)"""
    return _coin.SoDebugError_setHandlerCallback(function, data)

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(source, format):
    """SoDebugError_post(char const *const source, char const *const format)"""
    return _coin.SoDebugError_post(source, format)

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

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

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__(SbVec2s self) -> SbVec2s
        __init__(SbVec2s self, short const [2] v) -> SbVec2s
        __init__(SbVec2s self, short x, short y) -> SbVec2s
        __init__(SbVec2s self, SbVec2us const & v) -> SbVec2s
        __init__(SbVec2s self, SbVec2b v) -> SbVec2s
        __init__(SbVec2s self, SbVec2i32 v) -> SbVec2s
        __init__(SbVec2s self, SbVec2f v) -> SbVec2s
        __init__(SbVec2s self, SbVec2d v) -> SbVec2s
        """
        this = _coin.new_SbVec2s(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec2s self, short const [2] v) -> SbVec2s
        setValue(SbVec2s self, short x, short y) -> SbVec2s
        setValue(SbVec2s self, SbVec2us const & v) -> SbVec2s
        setValue(SbVec2s self, SbVec2b v) -> SbVec2s
        setValue(SbVec2s self, SbVec2i32 v) -> SbVec2s
        setValue(SbVec2s self, SbVec2f v) -> SbVec2s
        setValue(SbVec2s self, SbVec2d v) -> SbVec2s
        """
        return _coin.SbVec2s_setValue(self, *args)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    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__(SbTime self) -> SbTime
        __init__(SbTime self, double const sec) -> SbTime
        __init__(SbTime self, int32_t const sec, long const usec) -> SbTime
        __init__(SbTime self, timeval const *const 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(SbTime 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(msec):
        """sleep(int msec)"""
        return _coin.SbTime_sleep(msec)

    sleep = staticmethod(sleep)

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


    def setMsecValue(self, msec):
        """setMsecValue(SbTime self, unsigned long const msec)"""
        return _coin.SbTime_setMsecValue(self, msec)


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


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


    def format(self, *args):
        """
        format(SbTime self, char const *const fmt) -> SbString
        format(SbTime self) -> SbString
        """
        return _coin.SbTime_format(self, *args)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def __div__(self, *args):
        """
        __div__(SbTime self, SbTime tm) -> double
        __div__(SbTime self, double const 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(msec):
    """SbTime_sleep(int msec)"""
    return _coin.SbTime_sleep(msec)

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__(SoEvent 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, type):
        """isOfType(SoEvent self, SoType type) -> SbBool"""
        return _coin.SoEvent_isOfType(self, type)


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

    getClassTypeId = staticmethod(getClassTypeId)

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


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


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


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


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


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


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


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


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


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


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


    def wasAltDown(self):
        """wasAltDown(SoEvent 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, notifbase):
        """__init__(SoNotRec self, SoBase notifbase) -> SoNotRec"""
        this = _coin.new_SoNotRec(notifbase)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setType(self, type):
        """setType(SoNotRec self, SoNotRec::Type const type)"""
        return _coin.SoNotRec_setType(self, type)


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


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


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


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


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

    __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__(SoNotList self) -> SoNotList
        __init__(SoNotList self, SoNotList nl) -> SoNotList
        """
        this = _coin.new_SoNotList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def append(self, *args):
        """
        append(SoNotList self, SoNotRec rec)
        append(SoNotList self, SoNotRec rec, SoField field)
        append(SoNotList self, SoNotRec rec, SoEngineOutput engineout)
        """
        return _coin.SoNotList_append(self, *args)


    def setLastType(self, type):
        """setLastType(SoNotList self, SoNotRec::Type const type)"""
        return _coin.SoNotList_setLastType(self, type)


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


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


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


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


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


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


    def output(self, *args):
        """
        output(SoNotList self, FILE *const file)
        output(SoNotList 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, ignore):
        """setIgnored(SoField self, SbBool ignore)"""
        return _coin.SoField_setIgnored(self, ignore)


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


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


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


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


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

    getClassTypeId = staticmethod(getClassTypeId)

    def isOfType(self, type):
        """isOfType(SoField self, SoType type) -> SbBool"""
        return _coin.SoField_isOfType(self, type)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

    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, type):
        """setFieldType(SoField self, int type)"""
        return _coin.SoField_setFieldType(self, type)


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


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


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


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


    def get(self):
        """get(SoField 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(SoMField self) -> int"""
        return _coin.SoMField_getNum(self)


    def setNum(self, num):
        """setNum(SoMField self, int const num)"""
        return _coin.SoMField_setNum(self, num)


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


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


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


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

    initClass = staticmethod(initClass)

    def enableDeleteValues(self):
        """enableDeleteValues(SoMField self)"""
        return _coin.SoMField_enableDeleteValues(self)


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


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


    def __len__(self):
        """__len__(SoMField self) -> int"""
        return _coin.SoMField___len__(self)


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

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__(SoAuditorList 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, auditor, type):
        """append(SoAuditorList self, void *const auditor, SoNotRec::Type const type)"""
        return _coin.SoAuditorList_append(self, auditor, type)


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


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


    def getType(self, index):
        """getType(SoAuditorList self, int const index) -> SoNotRec::Type"""
        return _coin.SoAuditorList_getType(self, index)


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


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


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


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

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(SoBase self)"""
        return _coin.SoBase_ref(self)


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


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


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


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


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


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


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

    getClassTypeId = staticmethod(getClassTypeId)

    def getName(self):
        """getName(SoBase self) -> SbName"""
        return _coin.SoBase_getName(self)


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


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

    addName = staticmethod(addName)

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

    removeName = staticmethod(removeName)

    def startNotify(self):
        """startNotify(SoBase self)"""
        return _coin.SoBase_startNotify(self)


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


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


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


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


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


    def shouldWrite(self):
        """shouldWrite(SoBase 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(name, type):
        """getNamedBase(SbName name, SoType type) -> SoBase"""
        return _coin.SoBase_getNamedBase(name, type)

    getNamedBase = staticmethod(getNamedBase)

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

    getNamedBases = staticmethod(getNamedBases)

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

    read = staticmethod(read)

    def setInstancePrefix(c):
        """setInstancePrefix(SbString c)"""
        return _coin.SoBase_setInstancePrefix(c)

    setInstancePrefix = staticmethod(setInstancePrefix)

    def setTraceRefs(trace):
        """setTraceRefs(SbBool trace)"""
        return _coin.SoBase_setTraceRefs(trace)

    setTraceRefs = staticmethod(setTraceRefs)

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

    getTraceRefs = staticmethod(getTraceRefs)

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

    connectRoute = staticmethod(connectRoute)

    def assertAlive(self):
        """assertAlive(SoBase self)"""
        return _coin.SoBase_assertAlive(self)


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

    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(base, name):
    """SoBase_addName(SoBase base, char const *const name)"""
    return _coin.SoBase_addName(base, name)

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

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

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

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

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

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

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

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

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

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

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


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

def intrusive_ptr_release(obj):
    """intrusive_ptr_release(SoBase obj)"""
    return _coin.intrusive_ptr_release(obj)
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__(SoBaseList self) -> SoBaseList
        __init__(SoBaseList self, int const size) -> SoBaseList
        __init__(SoBaseList 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, ptr):
        """append(SoBaseList self, SoBase ptr)"""
        return _coin.SoBaseList_append(self, ptr)


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


    def remove(self, index):
        """remove(SoBaseList self, int const index)"""
        return _coin.SoBaseList_remove(self, index)


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


    def truncate(self, length):
        """truncate(SoBaseList self, int const length)"""
        return _coin.SoBaseList_truncate(self, length)


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


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


    def addReferences(self, flag):
        """addReferences(SoBaseList self, SbBool const flag)"""
        return _coin.SoBaseList_addReferences(self, flag)


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


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


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


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

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__(SoNodeList self) -> SoNodeList
        __init__(SoNodeList self, int const size) -> SoNodeList
        __init__(SoNodeList 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, ptr):
        """append(SoNodeList self, SoNode ptr)"""
        return _coin.SoNodeList_append(self, ptr)


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


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


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

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__(SoDetailList self) -> SoDetailList
        __init__(SoDetailList self, int const sizehint) -> SoDetailList
        __init__(SoDetailList 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, detail):
        """append(SoDetailList self, SoDetail detail)"""
        return _coin.SoDetailList_append(self, detail)


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


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


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


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


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


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


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

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__(SoTypeList self) -> SoTypeList
        __init__(SoTypeList self, int const sizehint) -> SoTypeList
        __init__(SoTypeList self, SoTypeList l) -> SoTypeList
        """
        this = _coin.new_SoTypeList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def append(self, type):
        """append(SoTypeList self, SoType type)"""
        return _coin.SoTypeList_append(self, type)


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


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


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


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


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


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

    __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, parentlist):
        """__init__(SoEnabledElementsList self, SoEnabledElementsList parentlist) -> SoEnabledElementsList"""
        this = _coin.new_SoEnabledElementsList(parentlist)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoEnabledElementsList
    __del__ = lambda self: None

    def getElements(self):
        """getElements(SoEnabledElementsList self) -> SoTypeList"""
        return _coin.SoEnabledElementsList_getElements(self)


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


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


    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__(SoEngineOutputList self) -> SoEngineOutputList
        __init__(SoEngineOutputList self, int const sizehint) -> SoEngineOutputList
        __init__(SoEngineOutputList self, SoEngineOutputList l) -> SoEngineOutputList
        """
        this = _coin.new_SoEngineOutputList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def append(self, output):
        """append(SoEngineOutputList self, SoEngineOutput output)"""
        return _coin.SoEngineOutputList_append(self, output)


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


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


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


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


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

    __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__(SoEngineList self) -> SoEngineList
        __init__(SoEngineList self, int const size) -> SoEngineList
        __init__(SoEngineList 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, ptr):
        """append(SoEngineList self, SoEngine ptr)"""
        return _coin.SoEngineList_append(self, ptr)


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


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


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

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__(SoFieldList self) -> SoFieldList
        __init__(SoFieldList self, int const sizehint) -> SoFieldList
        __init__(SoFieldList self, SoFieldList l) -> SoFieldList
        """
        this = _coin.new_SoFieldList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def append(self, field):
        """append(SoFieldList self, SoField field)"""
        return _coin.SoFieldList_append(self, field)


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


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


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


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


    def get(self, *args):
        """
        get(SoFieldList self, int const idx) -> SoField
        get(SoFieldList self, int const 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__(SoPathList self) -> SoPathList
        __init__(SoPathList self, int const size) -> SoPathList
        __init__(SoPathList 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, path):
        """append(SoPathList self, SoPath path)"""
        return _coin.SoPathList_append(self, path)


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


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


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


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


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


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

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__(SoPickedPointList self) -> SoPickedPointList
        __init__(SoPickedPointList self, int const sizehint) -> SoPickedPointList
        __init__(SoPickedPointList 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, pp):
        """append(SoPickedPointList self, SoPickedPoint pp)"""
        return _coin.SoPickedPointList_append(self, pp)


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


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


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


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


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


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

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__(SoPath self, int const approxlength=4) -> SoPath
        __init__(SoPath self) -> SoPath
        __init__(SoPath self, SoNode head) -> SoPath
        __init__(SoPath 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(SoPath self) -> SoType"""
        return _coin.SoPath_getTypeId(self)


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


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


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


    def push(self, childindex):
        """push(SoPath self, int const childindex)"""
        return _coin.SoPath_push(self, childindex)


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


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


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


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


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


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


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


    def truncate(self, length):
        """truncate(SoPath self, int const length)"""
        return _coin.SoPath_truncate(self, length)


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


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


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


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


    def copy(self, startfromnodeindex=0, numnodes=0):
        """
        copy(SoPath self, int const startfromnodeindex=0, int numnodes=0) -> SoPath
        copy(SoPath self, int const startfromnodeindex=0) -> SoPath
        copy(SoPath 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, parent, newindex):
        """insertIndex(SoPath self, SoNode parent, int const newindex)"""
        return _coin.SoPath_insertIndex(self, parent, newindex)


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


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


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


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


    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, u):
        """__eq__(SoPath self, SoPath u) -> int"""
        return _coin.SoPath___eq__(self, u)


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

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__(SoLightPath self, SoNode node, int const approxlength) -> SoLightPath
        __init__(SoLightPath self, int const 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, node):
        """setHead(SoLightPath self, SoNode node)"""
        return _coin.SoLightPath_setHead(self, node)


    def append(self, childindex):
        """append(SoLightPath self, int const childindex)"""
        return _coin.SoLightPath_append(self, childindex)


    def push(self, childindex):
        """push(SoLightPath self, int const childindex)"""
        return _coin.SoLightPath_push(self, childindex)


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


    def setTail(self, childindex):
        """setTail(SoLightPath self, int const childindex)"""
        return _coin.SoLightPath_setTail(self, childindex)


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


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


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


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


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


    def truncate(self, startindex):
        """truncate(SoLightPath self, int const startindex)"""
        return _coin.SoLightPath_truncate(self, startindex)


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

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(SoFullPath self)"""
        return _coin.SoFullPath_pop(self)


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


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


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


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


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

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

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

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')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def simpleAppend(self, node, index):
        """simpleAppend(SoTempPath self, SoNode node, int const index)"""
        return _coin.SoTempPath_simpleAppend(self, node, index)


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

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, parentlist):
        """__init__(SoActionMethodList self, SoActionMethodList parentlist) -> SoActionMethodList"""
        this = _coin.new_SoActionMethodList(parentlist)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoActionMethodList
    __del__ = lambda self: None

    def addMethod(self, node, method):
        """addMethod(SoActionMethodList self, SoType node, SoActionMethod const method)"""
        return _coin.SoActionMethodList_addMethod(self, node, method)


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


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


    def __getitem__(self, i):
        """__getitem__(SoActionMethodList self, int const i) -> SoActionMethod &"""
        return _coin.SoActionMethodList___getitem__(self, i)


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

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(SoAction self) -> SoType"""
        return _coin.SoAction_getTypeId(self)


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


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


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


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

    nullAction = staticmethod(nullAction)

    def getWhatAppliedTo(self):
        """getWhatAppliedTo(SoAction self) -> SoAction::AppliedCode"""
        return _coin.SoAction_getWhatAppliedTo(self)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

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(action, node):
    """SoAction_nullAction(SoAction action, SoNode node)"""
    return _coin.SoAction_nullAction(action, node)

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, action, enabledelements):
        """__init__(SoState self, SoAction action, SoTypeList enabledelements) -> SoState"""
        this = _coin.new_SoState(action, enabledelements)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoState
    __del__ = lambda self: None

    def getAction(self):
        """getAction(SoState self) -> SoAction"""
        return _coin.SoState_getAction(self)


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


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


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


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


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


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


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


    def setCacheOpen(self, flag):
        """setCacheOpen(SoState self, SbBool const flag)"""
        return _coin.SoState_setCacheOpen(self, flag)


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


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

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(SoElement self) -> SoType"""
        return _coin.SoElement_getTypeId(self)


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


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


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


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


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


    def copyMatchInfo(self):
        """copyMatchInfo(SoElement 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(stackIndex):
        """getIdFromStackIndex(int const stackIndex) -> SoType"""
        return _coin.SoElement_getIdFromStackIndex(stackIndex)

    getIdFromStackIndex = staticmethod(getIdFromStackIndex)

    def setDepth(self, depth):
        """setDepth(SoElement self, int const depth)"""
        return _coin.SoElement_setDepth(self, depth)


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


    def output(self, *args):
        """
        output(SoElement self, FILE * file)
        output(SoElement 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(stackIndex):
    """SoElement_getIdFromStackIndex(int const stackIndex) -> SoType"""
    return _coin.SoElement_getIdFromStackIndex(stackIndex)

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, state):
        """init(SoInt32Element self, SoState state)"""
        return _coin.SoInt32Element_init(self, state)


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


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


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


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

    set = staticmethod(set)

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

    get = staticmethod(get)

    def setElt(self, value):
        """setElt(SoInt32Element self, int32_t value)"""
        return _coin.SoInt32Element_setElt(self, value)

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 const index, SoState state, SoNode node, int32_t const value)
    SoInt32Element_set(int const index, SoState state, int32_t const value)
    """
    return _coin.SoInt32Element_set(*args)

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

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, state):
        """init(SoDecimationTypeElement self, SoState state)"""
        return _coin.SoDecimationTypeElement_init(self, state)


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

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoDecimationTypeElement::Type"""
        return _coin.SoDecimationTypeElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoDecimationTypeElement::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, SoDecimationTypeElement::Type const type)
    SoDecimationTypeElement_set(SoState state, SoNode node, SoDecimationTypeElement::Type const type)
    """
    return _coin.SoDecimationTypeElement_set(*args)

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

def SoDecimationTypeElement_getDefault():
    """SoDecimationTypeElement_getDefault() -> SoDecimationTypeElement::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__(SoFieldData self) -> SoFieldData
        __init__(SoFieldData self, SoFieldData fd) -> SoFieldData
        __init__(SoFieldData self, SoFieldData fd) -> SoFieldData
        __init__(SoFieldData 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, base, name, field):
        """addField(SoFieldData self, SoFieldContainer base, char const * name, SoField field)"""
        return _coin.SoFieldData_addField(self, base, name, field)


    def overlay(self, to, arg3, copyconnections):
        """overlay(SoFieldData self, SoFieldContainer to, SoFieldContainer arg3, SbBool copyconnections)"""
        return _coin.SoFieldData_overlay(self, to, arg3, copyconnections)


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


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


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


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


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


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


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


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


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


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


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


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

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(SoFieldContainer self)"""
        return _coin.SoFieldContainer_setToDefaults(self)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def copyContents(self, arg2, copyconnections):
        """copyContents(SoFieldContainer self, SoFieldContainer arg2, SbBool copyconnections)"""
        return _coin.SoFieldContainer_copyContents(self, arg2, copyconnections)


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


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

    initCopyDict = staticmethod(initCopyDict)

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

    addCopy = staticmethod(addCopy)

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

    checkCopy = staticmethod(checkCopy)

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

    findCopy = staticmethod(findCopy)

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

    copyDone = staticmethod(copyDone)

    def getFieldsMemorySize(self, managed, unmanaged):
        """getFieldsMemorySize(SoFieldContainer self, size_t & managed, size_t & unmanaged)"""
        return _coin.SoFieldContainer_getFieldsMemorySize(self, managed, unmanaged)


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


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


    def getFieldName(self, *args):
        """
        getFieldName(SoFieldContainer self, SoField field, SbName name) -> SbBool
        getFieldName(SoFieldContainer 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(orig, copy):
    """SoFieldContainer_addCopy(SoFieldContainer orig, SoFieldContainer copy)"""
    return _coin.SoFieldContainer_addCopy(orig, copy)

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

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

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, state):
        """setOverride(SoNode self, SbBool const state)"""
        return _coin.SoNode_setOverride(self, state)


    def isOverride(self):
        """isOverride(SoNode 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(nodetype):
        """getCompatibilityTypes(SoType nodetype) -> uint32_t"""
        return _coin.SoNode_getCompatibilityTypes(nodetype)

    getCompatibilityTypes = staticmethod(getCompatibilityTypes)

    def setNodeType(self, type):
        """setNodeType(SoNode self, SoNode::NodeType const type)"""
        return _coin.SoNode_setNodeType(self, type)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def copyContents(self, arg2, copyconnections):
        """copyContents(SoNode self, SoFieldContainer arg2, SbBool copyconnections)"""
        return _coin.SoNode_copyContents(self, arg2, copyconnections)


    def copyThroughConnection(self):
        """copyThroughConnection(SoNode 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(type):
        """getActionMethodIndex(SoType type) -> int"""
        return _coin.SoNode_getActionMethodIndex(type)

    getActionMethodIndex = staticmethod(getActionMethodIndex)

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

    getBoundingBoxS = staticmethod(getBoundingBoxS)

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

    GLRenderS = staticmethod(GLRenderS)

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

    callbackS = staticmethod(callbackS)

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

    getMatrixS = staticmethod(getMatrixS)

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

    handleEventS = staticmethod(handleEventS)

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

    pickS = staticmethod(pickS)

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

    rayPickS = staticmethod(rayPickS)

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

    searchS = staticmethod(searchS)

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

    writeS = staticmethod(writeS)

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

    audioRenderS = staticmethod(audioRenderS)

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

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

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

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(type):
    """SoNode_getActionMethodIndex(SoType type) -> int"""
    return _coin.SoNode_getActionMethodIndex(type)

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

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

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

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

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

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

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

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

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

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

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

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__(SoSensorManager 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, s):
        """insertDelaySensor(SoSensorManager self, SoDelayQueueSensor s)"""
        return _coin.SoSensorManager_insertDelaySensor(self, s)


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


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


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


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


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


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


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


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


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


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


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


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


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


    def isTimerSensorPending(self, *args):
        """
        isTimerSensorPending(SoSensorManager self, SbTime tm) -> SbBool
        isTimerSensorPending(SoSensorManager 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 const *"""
        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(input):
        """readAll(SoInput input) -> SoSeparator"""
        return _coin.SoDB_readAll(input)

    readAll = staticmethod(readAll)

    def readAllVRML(input):
        """readAllVRML(SoInput input) -> SoVRMLGroup"""
        return _coin.SoDB_readAllVRML(input)

    readAllVRML = staticmethod(readAllVRML)

    def isValidHeader(teststring):
        """isValidHeader(char const * teststring) -> SbBool"""
        return _coin.SoDB_isValidHeader(teststring)

    isValidHeader = staticmethod(isValidHeader)

    def registerHeader(headerstring, isbinary, ivversion, precallback, postcallback, userdata=None):
        """
        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(headerstring, isbinary, ivversion, precallback, postcallback, userdata)

    registerHeader = staticmethod(registerHeader)

    def getHeaderData(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok=0):
        """
        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(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok)

    getHeaderData = staticmethod(getHeaderData)

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

    getNumHeaders = staticmethod(getNumHeaders)

    def getHeaderString(i):
        """getHeaderString(int const i) -> SbString"""
        return _coin.SoDB_getHeaderString(i)

    getHeaderString = staticmethod(getHeaderString)

    def createGlobalField(name, type):
        """createGlobalField(SbName name, SoType type) -> SoField"""
        return _coin.SoDB_createGlobalField(name, type)

    createGlobalField = staticmethod(createGlobalField)

    def getGlobalField(name):
        """getGlobalField(SbName name) -> SoField"""
        return _coin.SoDB_getGlobalField(name)

    getGlobalField = staticmethod(getGlobalField)

    def renameGlobalField(arg1, to):
        """renameGlobalField(SbName arg1, SbName to)"""
        return _coin.SoDB_renameGlobalField(arg1, to)

    renameGlobalField = staticmethod(renameGlobalField)

    def setRealTimeInterval(interval):
        """setRealTimeInterval(SbTime interval)"""
        return _coin.SoDB_setRealTimeInterval(interval)

    setRealTimeInterval = staticmethod(setRealTimeInterval)

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

    getRealTimeInterval = staticmethod(getRealTimeInterval)

    def enableRealTimeSensor(on):
        """enableRealTimeSensor(SbBool on)"""
        return _coin.SoDB_enableRealTimeSensor(on)

    enableRealTimeSensor = staticmethod(enableRealTimeSensor)

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

    getSensorManager = staticmethod(getSensorManager)

    def setDelaySensorTimeout(t):
        """setDelaySensorTimeout(SbTime t)"""
        return _coin.SoDB_setDelaySensorTimeout(t)

    setDelaySensorTimeout = staticmethod(setDelaySensorTimeout)

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

    getDelaySensorTimeout = staticmethod(getDelaySensorTimeout)

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

    doSelect = staticmethod(doSelect)

    def addConverter(arg1, to, converter):
        """addConverter(SoType arg1, SoType to, SoType converter)"""
        return _coin.SoDB_addConverter(arg1, to, converter)

    addConverter = staticmethod(addConverter)

    def getConverter(arg1, to):
        """getConverter(SoType arg1, SoType to) -> SoType"""
        return _coin.SoDB_getConverter(arg1, to)

    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(func, userdata):
        """addProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
        return _coin.SoDB_addProgressCallback(func, userdata)

    addProgressCallback = staticmethod(addProgressCallback)

    def removeProgressCallback(func, userdata):
        """removeProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
        return _coin.SoDB_removeProgressCallback(func, userdata)

    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(arg1, eventout, to, eventin):
        """createRoute(SoNode arg1, char const * eventout, SoNode to, char const * eventin)"""
        return _coin.SoDB_createRoute(arg1, eventout, to, eventin)

    createRoute = staticmethod(createRoute)

    def removeRoute(arg1, eventout, to, eventin):
        """removeRoute(SoNode arg1, char const * eventout, SoNode to, char const * eventin)"""
        return _coin.SoDB_removeRoute(arg1, eventout, to, eventin)

    removeRoute = staticmethod(removeRoute)

    def __init__(self):
        """__init__(SoDB 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 const *"""
    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(input):
    """SoDB_readAll(SoInput input) -> SoSeparator"""
    return _coin.SoDB_readAll(input)

def SoDB_readAllVRML(input):
    """SoDB_readAllVRML(SoInput input) -> SoVRMLGroup"""
    return _coin.SoDB_readAllVRML(input)

def SoDB_isValidHeader(teststring):
    """SoDB_isValidHeader(char const * teststring) -> SbBool"""
    return _coin.SoDB_isValidHeader(teststring)

def SoDB_registerHeader(headerstring, isbinary, ivversion, precallback, postcallback, userdata=None):
    """
    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(headerstring, isbinary, ivversion, precallback, postcallback, userdata)

def SoDB_getHeaderData(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok=0):
    """
    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(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok)

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

def SoDB_getHeaderString(i):
    """SoDB_getHeaderString(int const i) -> SbString"""
    return _coin.SoDB_getHeaderString(i)

def SoDB_createGlobalField(name, type):
    """SoDB_createGlobalField(SbName name, SoType type) -> SoField"""
    return _coin.SoDB_createGlobalField(name, type)

def SoDB_getGlobalField(name):
    """SoDB_getGlobalField(SbName name) -> SoField"""
    return _coin.SoDB_getGlobalField(name)

def SoDB_renameGlobalField(arg2, to):
    """SoDB_renameGlobalField(SbName arg2, SbName to)"""
    return _coin.SoDB_renameGlobalField(arg2, to)

def SoDB_setRealTimeInterval(interval):
    """SoDB_setRealTimeInterval(SbTime interval)"""
    return _coin.SoDB_setRealTimeInterval(interval)

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

def SoDB_enableRealTimeSensor(on):
    """SoDB_enableRealTimeSensor(SbBool on)"""
    return _coin.SoDB_enableRealTimeSensor(on)

def SoDB_getSensorManager():
    """SoDB_getSensorManager() -> SoSensorManager"""
    return _coin.SoDB_getSensorManager()

def SoDB_setDelaySensorTimeout(t):
    """SoDB_setDelaySensorTimeout(SbTime t)"""
    return _coin.SoDB_setDelaySensorTimeout(t)

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

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

def SoDB_addConverter(arg2, to, converter):
    """SoDB_addConverter(SoType arg2, SoType to, SoType converter)"""
    return _coin.SoDB_addConverter(arg2, to, converter)

def SoDB_getConverter(arg2, to):
    """SoDB_getConverter(SoType arg2, SoType to) -> SoType"""
    return _coin.SoDB_getConverter(arg2, to)

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(func, userdata):
    """SoDB_addProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
    return _coin.SoDB_addProgressCallback(func, userdata)

def SoDB_removeProgressCallback(func, userdata):
    """SoDB_removeProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
    return _coin.SoDB_removeProgressCallback(func, userdata)

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(arg2, eventout, to, eventin):
    """SoDB_createRoute(SoNode arg2, char const * eventout, SoNode to, char const * eventin)"""
    return _coin.SoDB_createRoute(arg2, eventout, to, eventin)

def SoDB_removeRoute(arg2, eventout, to, eventin):
    """SoDB_removeRoute(SoNode arg2, char const * eventout, SoNode to, char const * eventin)"""
    return _coin.SoDB_removeRoute(arg2, eventout, to, eventin)

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__(SoInput self) -> SoInput
        __init__(SoInput self, SoInput dictIn) -> SoInput
        """
        this = _coin.new_SoInput(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def findProto(self, name):
        """findProto(SoInput self, SbName name) -> SoProto"""
        return _coin.SoInput_findProto(self, name)


    def addProto(self, proto):
        """addProto(SoInput self, SoProto proto)"""
        return _coin.SoInput_addProto(self, proto)


    def pushProto(self, proto):
        """pushProto(SoInput self, SoProto proto)"""
        return _coin.SoInput_pushProto(self, proto)


    def getCurrentProto(self):
        """getCurrentProto(SoInput self) -> SoProto"""
        return _coin.SoInput_getCurrentProto(self)


    def popProto(self):
        """popProto(SoInput self)"""
        return _coin.SoInput_popProto(self)


    def addRoute(self, fromnode, fromfield, tonode, tofield):
        """addRoute(SoInput self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"""
        return _coin.SoInput_addRoute(self, fromnode, fromfield, tonode, tofield)


    def checkISReference(self, container, fieldname, readok):
        """checkISReference(SoInput self, SoFieldContainer container, SbName fieldname, SbBool & readok) -> SbBool"""
        return _coin.SoInput_checkISReference(self, container, fieldname, readok)

    __swig_destroy__ = _coin.delete_SoInput
    __del__ = lambda self: None

    def setFilePointer(self, newFP):
        """setFilePointer(SoInput self, FILE * newFP)"""
        return _coin.SoInput_setFilePointer(self, newFP)


    def openFile(self, fileName, okIfNotFound=0):
        """
        openFile(SoInput self, char const * fileName, SbBool okIfNotFound=0) -> SbBool
        openFile(SoInput self, char const * fileName) -> SbBool
        """
        return _coin.SoInput_openFile(self, fileName, okIfNotFound)


    def pushFile(self, fileName):
        """pushFile(SoInput self, char const * fileName) -> SbBool"""
        return _coin.SoInput_pushFile(self, fileName)


    def closeFile(self):
        """closeFile(SoInput self)"""
        return _coin.SoInput_closeFile(self)


    def isValidFile(self):
        """isValidFile(SoInput self) -> SbBool"""
        return _coin.SoInput_isValidFile(self)


    def isValidBuffer(self):
        """isValidBuffer(SoInput self) -> SbBool"""
        return _coin.SoInput_isValidBuffer(self)


    def getCurFile(self):
        """getCurFile(SoInput self) -> FILE *"""
        return _coin.SoInput_getCurFile(self)


    def getCurFileName(self):
        """getCurFileName(SoInput self) -> char const *"""
        return _coin.SoInput_getCurFileName(self)


    def setBuffer(self, bufpointer):
        """setBuffer(SoInput self, void * bufpointer)"""
        return _coin.SoInput_setBuffer(self, bufpointer)


    def setStringArray(self, strings):
        """setStringArray(SoInput self, char const *[] strings)"""
        return _coin.SoInput_setStringArray(self, strings)


    def getNumBytesRead(self):
        """getNumBytesRead(SoInput self) -> size_t"""
        return _coin.SoInput_getNumBytesRead(self)


    def getHeader(self):
        """getHeader(SoInput self) -> SbString"""
        return _coin.SoInput_getHeader(self)


    def getIVVersion(self):
        """getIVVersion(SoInput self) -> float"""
        return _coin.SoInput_getIVVersion(self)


    def isBinary(self):
        """isBinary(SoInput self) -> SbBool"""
        return _coin.SoInput_isBinary(self)


    def get(self, c):
        """get(SoInput self, char & c) -> SbBool"""
        return _coin.SoInput_get(self, c)


    def getASCIIBuffer(self, c):
        """getASCIIBuffer(SoInput self, char & c) -> SbBool"""
        return _coin.SoInput_getASCIIBuffer(self, c)


    def getASCIIFile(self, c):
        """getASCIIFile(SoInput self, char & c) -> SbBool"""
        return _coin.SoInput_getASCIIFile(self, c)


    def readHex(self, l):
        """readHex(SoInput self, uint32_t & l) -> SbBool"""
        return _coin.SoInput_readHex(self, l)


    def read(self, *args):
        """
        read(SoInput self, char & c) -> SbBool
        read(SoInput self, char & c, SbBool skip) -> SbBool
        read(SoInput self, SbString s) -> SbBool
        read(SoInput self, SbName n, SbBool validIdent=0) -> SbBool
        read(SoInput self, SbName n) -> SbBool
        read(SoInput self, int & i) -> SbBool
        read(SoInput self, unsigned int & i) -> SbBool
        read(SoInput self, short & s) -> SbBool
        read(SoInput self, unsigned short & s) -> SbBool
        read(SoInput self, float & f) -> SbBool
        read(SoInput self, double & d) -> SbBool
        """
        return _coin.SoInput_read(self, *args)


    def readByte(self, *args):
        """
        readByte(SoInput self, int8_t & b) -> SbBool
        readByte(SoInput self, uint8_t & b) -> SbBool
        """
        return _coin.SoInput_readByte(self, *args)


    def readBinaryArray(self, *args):
        """
        readBinaryArray(SoInput self, unsigned char * c, int length) -> SbBool
        readBinaryArray(SoInput self, int32_t * l, int length) -> SbBool
        readBinaryArray(SoInput self, float * f, int length) -> SbBool
        readBinaryArray(SoInput self, double * d, int length) -> SbBool
        """
        return _coin.SoInput_readBinaryArray(self, *args)


    def eof(self):
        """eof(SoInput self) -> SbBool"""
        return _coin.SoInput_eof(self)


    def isFileVRML1(self):
        """isFileVRML1(SoInput self) -> SbBool"""
        return _coin.SoInput_isFileVRML1(self)


    def isFileVRML2(self):
        """isFileVRML2(SoInput self) -> SbBool"""
        return _coin.SoInput_isFileVRML2(self)


    def resetFilePointer(self, fptr):
        """resetFilePointer(SoInput self, FILE * fptr)"""
        return _coin.SoInput_resetFilePointer(self, fptr)


    def getLocationString(self, string):
        """getLocationString(SoInput self, SbString string)"""
        return _coin.SoInput_getLocationString(self, string)


    def putBack(self, *args):
        """
        putBack(SoInput self, char const c)
        putBack(SoInput self, char const * str)
        """
        return _coin.SoInput_putBack(self, *args)


    def addReference(self, name, base, addToGlobalDict=1):
        """
        addReference(SoInput self, SbName name, SoBase base, SbBool addToGlobalDict=1)
        addReference(SoInput self, SbName name, SoBase base)
        """
        return _coin.SoInput_addReference(self, name, base, addToGlobalDict)


    def removeReference(self, name):
        """removeReference(SoInput self, SbName name)"""
        return _coin.SoInput_removeReference(self, name)


    def findReference(self, name):
        """findReference(SoInput self, SbName name) -> SoBase"""
        return _coin.SoInput_findReference(self, name)


    def addDirectoryFirst(dirName):
        """addDirectoryFirst(char const * dirName)"""
        return _coin.SoInput_addDirectoryFirst(dirName)

    addDirectoryFirst = staticmethod(addDirectoryFirst)

    def addDirectoryLast(dirName):
        """addDirectoryLast(char const * dirName)"""
        return _coin.SoInput_addDirectoryLast(dirName)

    addDirectoryLast = staticmethod(addDirectoryLast)

    def addEnvDirectoriesFirst(*args):
        """
        addEnvDirectoriesFirst(char const * envVarName, char const * separator)
        addEnvDirectoriesFirst(char const * envVarName)
        """
        return _coin.SoInput_addEnvDirectoriesFirst(*args)

    addEnvDirectoriesFirst = staticmethod(addEnvDirectoriesFirst)

    def addEnvDirectoriesLast(*args):
        """
        addEnvDirectoriesLast(char const * envVarName, char const * separator)
        addEnvDirectoriesLast(char const * envVarName)
        """
        return _coin.SoInput_addEnvDirectoriesLast(*args)

    addEnvDirectoriesLast = staticmethod(addEnvDirectoriesLast)

    def removeDirectory(dirName):
        """removeDirectory(char const * dirName)"""
        return _coin.SoInput_removeDirectory(dirName)

    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 const *const filename) -> SbString
        getPathname(SbString s) -> SbString
        """
        return _coin.SoInput_getPathname(*args)

    getPathname = staticmethod(getPathname)

    def getBasename(*args):
        """
        getBasename(char const *const filename) -> SbString
        getBasename(SbString s) -> SbString
        """
        return _coin.SoInput_getBasename(*args)

    getBasename = staticmethod(getBasename)

    def searchForFile(basename, directories, subdirectories):
        """searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"""
        return _coin.SoInput_searchForFile(basename, directories, subdirectories)

    searchForFile = staticmethod(searchForFile)
SoInput_swigregister = _coin.SoInput_swigregister
SoInput_swigregister(SoInput)

def SoInput_addDirectoryFirst(dirName):
    """SoInput_addDirectoryFirst(char const * dirName)"""
    return _coin.SoInput_addDirectoryFirst(dirName)

def SoInput_addDirectoryLast(dirName):
    """SoInput_addDirectoryLast(char const * dirName)"""
    return _coin.SoInput_addDirectoryLast(dirName)

def SoInput_addEnvDirectoriesFirst(*args):
    """
    addEnvDirectoriesFirst(char const * envVarName, char const * separator)
    SoInput_addEnvDirectoriesFirst(char const * envVarName)
    """
    return _coin.SoInput_addEnvDirectoriesFirst(*args)

def SoInput_addEnvDirectoriesLast(*args):
    """
    addEnvDirectoriesLast(char const * envVarName, char const * separator)
    SoInput_addEnvDirectoriesLast(char const * envVarName)
    """
    return _coin.SoInput_addEnvDirectoriesLast(*args)

def SoInput_removeDirectory(dirName):
    """SoInput_removeDirectory(char const * dirName)"""
    return _coin.SoInput_removeDirectory(dirName)

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 const *const filename) -> SbString
    SoInput_getPathname(SbString s) -> SbString
    """
    return _coin.SoInput_getPathname(*args)

def SoInput_getBasename(*args):
    """
    getBasename(char const *const filename) -> SbString
    SoInput_getBasename(SbString s) -> SbString
    """
    return _coin.SoInput_getBasename(*args)

def SoInput_searchForFile(basename, directories, subdirectories):
    """SoInput_searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"""
    return _coin.SoInput_searchForFile(basename, directories, subdirectories)

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__(SoOutput self) -> SoOutput
        __init__(SoOutput 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, newFP):
        """setFilePointer(SoOutput self, FILE * newFP)"""
        return _coin.SoOutput_setFilePointer(self, newFP)


    def getFilePointer(self):
        """getFilePointer(SoOutput self) -> FILE *"""
        return _coin.SoOutput_getFilePointer(self)


    def openFile(self, fileName):
        """openFile(SoOutput self, char const *const fileName) -> SbBool"""
        return _coin.SoOutput_openFile(self, fileName)


    def closeFile(self):
        """closeFile(SoOutput self)"""
        return _coin.SoOutput_closeFile(self)


    def setCompression(self, compmethod, level=0.5):
        """
        setCompression(SoOutput self, SbName compmethod, float const level=0.5) -> SbBool
        setCompression(SoOutput self, SbName compmethod) -> SbBool
        """
        return _coin.SoOutput_setCompression(self, compmethod, level)


    def getAvailableCompressionMethods(num):
        """getAvailableCompressionMethods(unsigned int & num) -> SbName"""
        return _coin.SoOutput_getAvailableCompressionMethods(num)

    getAvailableCompressionMethods = staticmethod(getAvailableCompressionMethods)

    def setBuffer(self, bufPointer, initSize, reallocFunc, offset=0):
        """
        setBuffer(SoOutput self, void * bufPointer, size_t initSize, SoOutputReallocCB * reallocFunc, int32_t offset=0)
        setBuffer(SoOutput self, void * bufPointer, size_t initSize, SoOutputReallocCB * reallocFunc)
        """
        return _coin.SoOutput_setBuffer(self, bufPointer, initSize, reallocFunc, offset)


    def getBuffer(self, bufPointer, nBytes):
        """getBuffer(SoOutput self, void *& bufPointer, size_t & nBytes) -> SbBool"""
        return _coin.SoOutput_getBuffer(self, bufPointer, nBytes)


    def getBufferSize(self):
        """getBufferSize(SoOutput self) -> size_t"""
        return _coin.SoOutput_getBufferSize(self)


    def resetBuffer(self):
        """resetBuffer(SoOutput self)"""
        return _coin.SoOutput_resetBuffer(self)


    def setBinary(self, flag):
        """setBinary(SoOutput self, SbBool const flag)"""
        return _coin.SoOutput_setBinary(self, flag)


    def isBinary(self):
        """isBinary(SoOutput self) -> SbBool"""
        return _coin.SoOutput_isBinary(self)


    def setHeaderString(self, str):
        """setHeaderString(SoOutput self, SbString str)"""
        return _coin.SoOutput_setHeaderString(self, str)


    def resetHeaderString(self):
        """resetHeaderString(SoOutput self)"""
        return _coin.SoOutput_resetHeaderString(self)


    def setFloatPrecision(self, precision):
        """setFloatPrecision(SoOutput self, int const precision)"""
        return _coin.SoOutput_setFloatPrecision(self, precision)


    def setStage(self, stage):
        """setStage(SoOutput self, SoOutput::Stage stage)"""
        return _coin.SoOutput_setStage(self, stage)


    def getStage(self):
        """getStage(SoOutput self) -> SoOutput::Stage"""
        return _coin.SoOutput_getStage(self)


    def incrementIndent(self, levels=1):
        """
        incrementIndent(SoOutput self, int const levels=1)
        incrementIndent(SoOutput self)
        """
        return _coin.SoOutput_incrementIndent(self, levels)


    def decrementIndent(self, levels=1):
        """
        decrementIndent(SoOutput self, int const levels=1)
        decrementIndent(SoOutput self)
        """
        return _coin.SoOutput_decrementIndent(self, levels)


    def write(self, *args):
        """
        write(SoOutput self, char const c)
        write(SoOutput self, char const * s)
        write(SoOutput self, SbString s)
        write(SoOutput self, SbName n)
        write(SoOutput self, int const i)
        write(SoOutput self, unsigned int const i)
        write(SoOutput self, short const s)
        write(SoOutput self, unsigned short const s)
        write(SoOutput self, float const f)
        write(SoOutput self, double const d)
        """
        return _coin.SoOutput_write(self, *args)


    def writeBinaryArray(self, *args):
        """
        writeBinaryArray(SoOutput self, unsigned char const * c, int const length)
        writeBinaryArray(SoOutput self, int32_t const *const l, int const length)
        writeBinaryArray(SoOutput self, float const *const f, int const length)
        writeBinaryArray(SoOutput self, double const *const d, int const length)
        """
        return _coin.SoOutput_writeBinaryArray(self, *args)


    def indent(self):
        """indent(SoOutput self)"""
        return _coin.SoOutput_indent(self)


    def reset(self):
        """reset(SoOutput self)"""
        return _coin.SoOutput_reset(self)


    def setCompact(self, flag):
        """setCompact(SoOutput self, SbBool flag)"""
        return _coin.SoOutput_setCompact(self, flag)


    def isCompact(self):
        """isCompact(SoOutput self) -> SbBool"""
        return _coin.SoOutput_isCompact(self)


    def setAnnotation(self, bits):
        """setAnnotation(SoOutput self, uint32_t bits)"""
        return _coin.SoOutput_setAnnotation(self, bits)


    def getAnnotation(self):
        """getAnnotation(SoOutput 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, base):
        """addReference(SoOutput self, SoBase base) -> int"""
        return _coin.SoOutput_addReference(self, base)


    def findReference(self, base):
        """findReference(SoOutput self, SoBase base) -> int"""
        return _coin.SoOutput_findReference(self, base)


    def setReference(self, base, refid):
        """setReference(SoOutput self, SoBase base, int refid)"""
        return _coin.SoOutput_setReference(self, base, refid)


    def addDEFNode(self, name):
        """addDEFNode(SoOutput self, SbName name)"""
        return _coin.SoOutput_addDEFNode(self, name)


    def lookupDEFNode(self, name):
        """lookupDEFNode(SoOutput self, SbName name) -> SbBool"""
        return _coin.SoOutput_lookupDEFNode(self, name)


    def removeDEFNode(self, name):
        """removeDEFNode(SoOutput self, SbName name)"""
        return _coin.SoOutput_removeDEFNode(self, name)


    def pushProto(self, proto):
        """pushProto(SoOutput self, SoProto proto)"""
        return _coin.SoOutput_pushProto(self, proto)


    def getCurrentProto(self):
        """getCurrentProto(SoOutput self) -> SoProto"""
        return _coin.SoOutput_getCurrentProto(self)


    def popProto(self):
        """popProto(SoOutput self)"""
        return _coin.SoOutput_popProto(self)


    def addRoute(self, arg2, fromfield, to, tofield):
        """addRoute(SoOutput self, SoFieldContainer arg2, SbName fromfield, SoFieldContainer to, SbName tofield)"""
        return _coin.SoOutput_addRoute(self, arg2, fromfield, to, tofield)


    def resolveRoutes(self):
        """resolveRoutes(SoOutput self)"""
        return _coin.SoOutput_resolveRoutes(self)

SoOutput_swigregister = _coin.SoOutput_swigregister
SoOutput_swigregister(SoOutput)

def SoOutput_getAvailableCompressionMethods(num):
    """SoOutput_getAvailableCompressionMethods(unsigned int & num) -> SbName"""
    return _coin.SoOutput_getAvailableCompressionMethods(num)

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__(SoSFEnum 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(SoSFEnum self) -> SoType"""
        return _coin.SoSFEnum_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFEnum self, SoField field)"""
        return _coin.SoSFEnum_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFEnum self, SoField field) -> SbBool"""
        return _coin.SoSFEnum_isSame(self, field)


    def getValue(self):
        """getValue(SoSFEnum self) -> int"""
        return _coin.SoSFEnum_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFEnum self, SoSFEnum field) -> int"""
        return _coin.SoSFEnum___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFEnum self, SoSFEnum field) -> int"""
        return _coin.SoSFEnum___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setEnums(self, num, vals, names):
        """setEnums(SoSFEnum self, int const num, int const * vals, SbName names)"""
        return _coin.SoSFEnum_setEnums(self, num, vals, names)


    def getNumEnums(self):
        """getNumEnums(SoSFEnum self) -> int"""
        return _coin.SoSFEnum_getNumEnums(self)


    def getEnum(self, idx, name):
        """getEnum(SoSFEnum self, int const idx, SbName name) -> int"""
        return _coin.SoSFEnum_getEnum(self, idx, name)


    def setValue(self, *args):
        """
        setValue(SoSFEnum self, int newvalue)
        setValue(SoSFEnum self, SbName name)
        setValue(SoSFEnum 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__(SoSFFloat 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(SoSFFloat self) -> SoType"""
        return _coin.SoSFFloat_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFFloat self, SoField field)"""
        return _coin.SoSFFloat_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFFloat self, SoField field) -> SbBool"""
        return _coin.SoSFFloat_isSame(self, field)


    def getValue(self):
        """getValue(SoSFFloat self) -> float"""
        return _coin.SoSFFloat_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFFloat self, SoSFFloat field) -> int"""
        return _coin.SoSFFloat___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFFloat self, SoSFFloat field) -> int"""
        return _coin.SoSFFloat___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFFloat self, float newvalue)
        setValue(SoSFFloat 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, state):
        """init(SoComplexityTypeElement self, SoState state)"""
        return _coin.SoComplexityTypeElement_init(self, state)


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

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoComplexityTypeElement::Type"""
        return _coin.SoComplexityTypeElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoComplexityTypeElement::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, SoComplexityTypeElement::Type const type)
    SoComplexityTypeElement_set(SoState state, SoComplexityTypeElement::Type const type)
    """
    return _coin.SoComplexityTypeElement_set(*args)

def SoComplexityTypeElement_get(state):
    """SoComplexityTypeElement_get(SoState state) -> SoComplexityTypeElement::Type"""
    return _coin.SoComplexityTypeElement_get(state)

def SoComplexityTypeElement_getDefault():
    """SoComplexityTypeElement_getDefault() -> SoComplexityTypeElement::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(SoComplexity self) -> SoType"""
        return _coin.SoComplexity_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoComplexity 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, action):
        """doAction(SoComplexity self, SoAction action)"""
        return _coin.SoComplexity_doAction(self, action)


    def callback(self, action):
        """callback(SoComplexity self, SoCallbackAction action)"""
        return _coin.SoComplexity_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoComplexity self, SoGetBoundingBoxAction action)"""
        return _coin.SoComplexity_getBoundingBox(self, action)


    def GLRender(self, action):
        """GLRender(SoComplexity self, SoGLRenderAction action)"""
        return _coin.SoComplexity_GLRender(self, action)


    def pick(self, action):
        """pick(SoComplexity self, SoPickAction action)"""
        return _coin.SoComplexity_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoComplexity self, SoGetPrimitiveCountAction action)"""
        return _coin.SoComplexity_getPrimitiveCount(self, action)

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, state):
        """init(SoDrawStyleElement self, SoState state)"""
        return _coin.SoDrawStyleElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, SoDrawStyleElement::Style const style)
        set(SoState state, SoDrawStyleElement::Style const style)
        """
        return _coin.SoDrawStyleElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoDrawStyleElement::Style"""
        return _coin.SoDrawStyleElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoDrawStyleElement::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, SoDrawStyleElement::Style const style)
    SoDrawStyleElement_set(SoState state, SoDrawStyleElement::Style const style)
    """
    return _coin.SoDrawStyleElement_set(*args)

def SoDrawStyleElement_get(state):
    """SoDrawStyleElement_get(SoState state) -> SoDrawStyleElement::Style"""
    return _coin.SoDrawStyleElement_get(state)

def SoDrawStyleElement_getDefault():
    """SoDrawStyleElement_getDefault() -> SoDrawStyleElement::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__(SoSFUShort 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(SoSFUShort self) -> SoType"""
        return _coin.SoSFUShort_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFUShort self, SoField field)"""
        return _coin.SoSFUShort_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFUShort self, SoField field) -> SbBool"""
        return _coin.SoSFUShort_isSame(self, field)


    def getValue(self):
        """getValue(SoSFUShort self) -> unsigned short"""
        return _coin.SoSFUShort_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFUShort self, SoSFUShort field) -> int"""
        return _coin.SoSFUShort___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFUShort self, SoSFUShort field) -> int"""
        return _coin.SoSFUShort___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFUShort self, unsigned short newvalue)
        setValue(SoSFUShort 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__(SoSFInt32 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(SoSFInt32 self) -> SoType"""
        return _coin.SoSFInt32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFInt32 self, SoField field)"""
        return _coin.SoSFInt32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFInt32 self, SoField field) -> SbBool"""
        return _coin.SoSFInt32_isSame(self, field)


    def getValue(self):
        """getValue(SoSFInt32 self) -> int32_t"""
        return _coin.SoSFInt32_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFInt32 self, SoSFInt32 field) -> int"""
        return _coin.SoSFInt32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFInt32 self, SoSFInt32 field) -> int"""
        return _coin.SoSFInt32___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFInt32 self, int32_t newvalue)
        setValue(SoSFInt32 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(SoDrawStyle self) -> SoType"""
        return _coin.SoDrawStyle_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoDrawStyle 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, action):
        """doAction(SoDrawStyle self, SoAction action)"""
        return _coin.SoDrawStyle_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoDrawStyle self, SoGLRenderAction action)"""
        return _coin.SoDrawStyle_GLRender(self, action)


    def callback(self, action):
        """callback(SoDrawStyle self, SoCallbackAction action)"""
        return _coin.SoDrawStyle_callback(self, action)

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__(SbVec3f self) -> SbVec3f
        __init__(SbVec3f self, float const [3] v) -> SbVec3f
        __init__(SbVec3f self, float x, float y, float z) -> SbVec3f
        __init__(SbVec3f self, SbVec3d v) -> SbVec3f
        __init__(SbVec3f self, SbVec3b v) -> SbVec3f
        __init__(SbVec3f self, SbVec3s v) -> SbVec3f
        __init__(SbVec3f self, SbVec3i32 v) -> SbVec3f
        __init__(SbVec3f 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(SbVec3f self, float const [3] v) -> SbVec3f
        setValue(SbVec3f self, float x, float y, float z) -> SbVec3f
        setValue(SbVec3f self, SbVec3f barycentric, SbVec3f v0, SbVec3f v1, SbVec3f v2) -> SbVec3f
        setValue(SbVec3f self, SbVec3d v) -> SbVec3f
        setValue(SbVec3f self, SbVec3b v) -> SbVec3f
        setValue(SbVec3f self, SbVec3s v) -> SbVec3f
        setValue(SbVec3f self, SbVec3i32 v) -> SbVec3f
        """
        return _coin.SbVec3f_setValue(self, *args)


    def getValue(self):
        """getValue(SbVec3f self) -> float const *"""
        return _coin.SbVec3f_getValue(self)


    def equals(self, v, tolerance):
        """equals(SbVec3f self, SbVec3f v, float tolerance) -> SbBool"""
        return _coin.SbVec3f_equals(self, v, tolerance)


    def cross(self, v):
        """cross(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f_cross(self, v)


    def dot(self, v):
        """dot(SbVec3f self, SbVec3f v) -> float"""
        return _coin.SbVec3f_dot(self, v)


    def getClosestAxis(self):
        """getClosestAxis(SbVec3f self) -> SbVec3f"""
        return _coin.SbVec3f_getClosestAxis(self)


    def length(self):
        """length(SbVec3f self) -> float"""
        return _coin.SbVec3f_length(self)


    def sqrLength(self):
        """sqrLength(SbVec3f self) -> float"""
        return _coin.SbVec3f_sqrLength(self)


    def normalize(self):
        """normalize(SbVec3f self) -> float"""
        return _coin.SbVec3f_normalize(self)


    def negate(self):
        """negate(SbVec3f self)"""
        return _coin.SbVec3f_negate(self)


    def __imul__(self, d):
        """__imul__(SbVec3f self, float d) -> SbVec3f"""
        return _coin.SbVec3f___imul__(self, d)


    def __idiv__(self, d):
        """__idiv__(SbVec3f self, float d) -> SbVec3f"""
        return _coin.SbVec3f___idiv__(self, d)


    def __iadd__(self, v):
        """__iadd__(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec3f self) -> SbVec3f"""
        return _coin.SbVec3f___neg__(self)


    def output(self, fp):
        """output(SbVec3f self, FILE * fp)"""
        return _coin.SbVec3f_output(self, fp)


    def __add__(self, u):
        """__add__(SbVec3f self, SbVec3f u) -> SbVec3f"""
        return _coin.SbVec3f___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbVec3f self, SbVec3f u) -> SbVec3f"""
        return _coin.SbVec3f___sub__(self, u)


    def __mul__(self, *args):
        """
        __mul__(SbVec3f self, float const d) -> SbVec3f
        __mul__(SbVec3f self, SbMatrix m) -> SbVec3f
        """
        return _coin.SbVec3f___mul__(self, *args)


    def __rmul__(self, d):
        """__rmul__(SbVec3f self, float const d) -> SbVec3f"""
        return _coin.SbVec3f___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbVec3f self, float const d) -> SbVec3f"""
        return _coin.SbVec3f___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbVec3f self, SbVec3f u) -> int"""
        return _coin.SbVec3f___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbVec3f self, SbVec3f u) -> int"""
        return _coin.SbVec3f___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbVec3f self, int i) -> float"""
        return _coin.SbVec3f___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SbVec3f self, int i, float value)"""
        return _coin.SbVec3f___setitem__(self, i, value)


    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__(SbColor self) -> SbColor
        __init__(SbColor self, SbVec3f v) -> SbColor
        __init__(SbColor self, float const *const rgb) -> SbColor
        __init__(SbColor self, float const r, float const g, float const b) -> SbColor
        """
        this = _coin.new_SbColor(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setHSVValue(self, *args):
        """
        setHSVValue(SbColor self, float h, float s, float v) -> SbColor
        setHSVValue(SbColor self, float const [3] hsv) -> SbColor
        """
        return _coin.SbColor_setHSVValue(self, *args)


    def getHSVValue(self):
        """getHSVValue(SbColor self)"""
        return _coin.SbColor_getHSVValue(self)


    def setPackedValue(self, rgba, transparency):
        """setPackedValue(SbColor self, uint32_t const rgba, float & transparency) -> SbColor"""
        return _coin.SbColor_setPackedValue(self, rgba, transparency)


    def getPackedValue(self, transparency=0.0):
        """
        getPackedValue(SbColor self, float const transparency=0.0) -> uint32_t
        getPackedValue(SbColor self) -> uint32_t
        """
        return _coin.SbColor_getPackedValue(self, transparency)


    def __add__(self, u):
        """__add__(SbColor self, SbColor u) -> SbColor"""
        return _coin.SbColor___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbColor self, SbColor u) -> SbColor"""
        return _coin.SbColor___sub__(self, u)


    def __mul__(self, d):
        """__mul__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___mul__(self, d)


    def __rmul__(self, d):
        """__rmul__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbColor self, SbColor u) -> int"""
        return _coin.SbColor___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbColor self, SbColor u) -> int"""
        return _coin.SbColor___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbColor self, int i) -> float"""
        return _coin.SbColor___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SbColor self, int i, float value)"""
        return _coin.SbColor___setitem__(self, i, value)

    __swig_destroy__ = _coin.delete_SbColor
    __del__ = lambda self: None
SbColor_swigregister = _coin.SbColor_swigregister
SbColor_swigregister(SbColor)


_coin.SO_LAZY_SHINY_THRESHOLD_swigconstant(_coin)
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, state):
        """init(SoLazyElement self, SoState state)"""
        return _coin.SoLazyElement_init(self, state)


    def push(self, state):
        """push(SoLazyElement self, SoState state)"""
        return _coin.SoLazyElement_push(self, state)


    def matches(self, arg2):
        """matches(SoLazyElement self, SoElement arg2) -> SbBool"""
        return _coin.SoLazyElement_matches(self, arg2)


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


    def setToDefault(state):
        """setToDefault(SoState state)"""
        return _coin.SoLazyElement_setToDefault(state)

    setToDefault = staticmethod(setToDefault)

    def setDiffuse(state, node, numcolors, colors, packer):
        """setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
        return _coin.SoLazyElement_setDiffuse(state, node, numcolors, colors, packer)

    setDiffuse = staticmethod(setDiffuse)

    def setTransparency(state, node, numvalues, transparency, packer):
        """setTransparency(SoState state, SoNode node, int32_t numvalues, float const * transparency, SoColorPacker packer)"""
        return _coin.SoLazyElement_setTransparency(state, node, numvalues, transparency, packer)

    setTransparency = staticmethod(setTransparency)

    def setColorIndices(state, node, numindices, indices):
        """setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t const * indices)"""
        return _coin.SoLazyElement_setColorIndices(state, node, numindices, indices)

    setColorIndices = staticmethod(setColorIndices)

    def setAmbient(state, color):
        """setAmbient(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setAmbient(state, color)

    setAmbient = staticmethod(setAmbient)

    def setEmissive(state, color):
        """setEmissive(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setEmissive(state, color)

    setEmissive = staticmethod(setEmissive)

    def setSpecular(state, color):
        """setSpecular(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setSpecular(state, color)

    setSpecular = staticmethod(setSpecular)

    def setShininess(state, value):
        """setShininess(SoState state, float value)"""
        return _coin.SoLazyElement_setShininess(state, value)

    setShininess = staticmethod(setShininess)

    def setColorMaterial(state, value):
        """setColorMaterial(SoState state, SbBool value)"""
        return _coin.SoLazyElement_setColorMaterial(state, value)

    setColorMaterial = staticmethod(setColorMaterial)

    def enableBlending(state, sfactor, dfactor):
        """enableBlending(SoState state, int sfactor, int dfactor)"""
        return _coin.SoLazyElement_enableBlending(state, sfactor, dfactor)

    enableBlending = staticmethod(enableBlending)

    def enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor):
        """enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
        return _coin.SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor)

    enableSeparateBlending = staticmethod(enableSeparateBlending)

    def disableBlending(state):
        """disableBlending(SoState state)"""
        return _coin.SoLazyElement_disableBlending(state)

    disableBlending = staticmethod(disableBlending)

    def setLightModel(state, model):
        """setLightModel(SoState state, int32_t const model)"""
        return _coin.SoLazyElement_setLightModel(state, model)

    setLightModel = staticmethod(setLightModel)

    def setVertexOrdering(state, ordering):
        """setVertexOrdering(SoState state, SoLazyElement::VertexOrdering ordering)"""
        return _coin.SoLazyElement_setVertexOrdering(state, ordering)

    setVertexOrdering = staticmethod(setVertexOrdering)

    def setBackfaceCulling(state, onoff):
        """setBackfaceCulling(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setBackfaceCulling(state, onoff)

    setBackfaceCulling = staticmethod(setBackfaceCulling)

    def setTwosideLighting(state, onoff):
        """setTwosideLighting(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setTwosideLighting(state, onoff)

    setTwosideLighting = staticmethod(setTwosideLighting)

    def setShadeModel(state, flatshading):
        """setShadeModel(SoState state, SbBool flatshading)"""
        return _coin.SoLazyElement_setShadeModel(state, flatshading)

    setShadeModel = staticmethod(setShadeModel)

    def setGLImageId(state, glimageid, alphatest):
        """setGLImageId(SoState state, uint32_t glimageid, SbBool alphatest)"""
        return _coin.SoLazyElement_setGLImageId(state, glimageid, alphatest)

    setGLImageId = staticmethod(setGLImageId)

    def setAlphaTest(state, onoff):
        """setAlphaTest(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setAlphaTest(state, onoff)

    setAlphaTest = staticmethod(setAlphaTest)

    def getDiffuse(state, index):
        """getDiffuse(SoState state, int index) -> SbColor"""
        return _coin.SoLazyElement_getDiffuse(state, index)

    getDiffuse = staticmethod(getDiffuse)

    def getTransparency(arg1, index):
        """getTransparency(SoState arg1, int index) -> float"""
        return _coin.SoLazyElement_getTransparency(arg1, index)

    getTransparency = staticmethod(getTransparency)

    def getPackedColors(arg1):
        """getPackedColors(SoState arg1) -> uint32_t const *"""
        return _coin.SoLazyElement_getPackedColors(arg1)

    getPackedColors = staticmethod(getPackedColors)

    def getColorIndices(arg1):
        """getColorIndices(SoState arg1) -> int32_t const *"""
        return _coin.SoLazyElement_getColorIndices(arg1)

    getColorIndices = staticmethod(getColorIndices)

    def getColorIndex(arg1, num):
        """getColorIndex(SoState arg1, int num) -> int32_t"""
        return _coin.SoLazyElement_getColorIndex(arg1, num)

    getColorIndex = staticmethod(getColorIndex)

    def getAmbient(arg1):
        """getAmbient(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getAmbient(arg1)

    getAmbient = staticmethod(getAmbient)

    def getEmissive(arg1):
        """getEmissive(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getEmissive(arg1)

    getEmissive = staticmethod(getEmissive)

    def getSpecular(arg1):
        """getSpecular(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getSpecular(arg1)

    getSpecular = staticmethod(getSpecular)

    def getShininess(arg1):
        """getShininess(SoState arg1) -> float"""
        return _coin.SoLazyElement_getShininess(arg1)

    getShininess = staticmethod(getShininess)

    def getColorMaterial(arg1):
        """getColorMaterial(SoState arg1) -> SbBool"""
        return _coin.SoLazyElement_getColorMaterial(arg1)

    getColorMaterial = staticmethod(getColorMaterial)

    def getBlending(arg1, sfactor, dfactor):
        """getBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
        return _coin.SoLazyElement_getBlending(arg1, sfactor, dfactor)

    getBlending = staticmethod(getBlending)

    def getAlphaBlending(arg1, sfactor, dfactor):
        """getAlphaBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
        return _coin.SoLazyElement_getAlphaBlending(arg1, sfactor, dfactor)

    getAlphaBlending = staticmethod(getAlphaBlending)

    def getLightModel(arg1):
        """getLightModel(SoState arg1) -> int32_t"""
        return _coin.SoLazyElement_getLightModel(arg1)

    getLightModel = staticmethod(getLightModel)

    def getAlphaTest(state):
        """getAlphaTest(SoState state) -> SbBool"""
        return _coin.SoLazyElement_getAlphaTest(state)

    getAlphaTest = staticmethod(getAlphaTest)

    def getNumDiffuse(self):
        """getNumDiffuse(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumDiffuse(self)


    def getNumTransparencies(self):
        """getNumTransparencies(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumTransparencies(self)


    def getNumColorIndices(self):
        """getNumColorIndices(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumColorIndices(self)


    def isPacked(self):
        """isPacked(SoLazyElement self) -> SbBool"""
        return _coin.SoLazyElement_isPacked(self)


    def isTransparent(self):
        """isTransparent(SoLazyElement self) -> SbBool"""
        return _coin.SoLazyElement_isTransparent(self)


    def getInstance(state):
        """getInstance(SoState state) -> SoLazyElement"""
        return _coin.SoLazyElement_getInstance(state)

    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(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent):
        """setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
        return _coin.SoLazyElement_setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)

    setMaterials = staticmethod(setMaterials)

    def getWInstance(state):
        """getWInstance(SoState state) -> SoLazyElement"""
        return _coin.SoLazyElement_getWInstance(state)

    getWInstance = staticmethod(getWInstance)

    def getPackedPointer(self):
        """getPackedPointer(SoLazyElement self) -> uint32_t const *"""
        return _coin.SoLazyElement_getPackedPointer(self)


    def getDiffusePointer(self):
        """getDiffusePointer(SoLazyElement self) -> SbColor"""
        return _coin.SoLazyElement_getDiffusePointer(self)


    def getColorIndexPointer(self):
        """getColorIndexPointer(SoLazyElement self) -> int32_t const *"""
        return _coin.SoLazyElement_getColorIndexPointer(self)


    def getTransparencyPointer(self):
        """getTransparencyPointer(SoLazyElement self) -> float const *"""
        return _coin.SoLazyElement_getTransparencyPointer(self)


    def setTransparencyType(state, type):
        """setTransparencyType(SoState state, int32_t type)"""
        return _coin.SoLazyElement_setTransparencyType(state, type)

    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(state):
    """SoLazyElement_setToDefault(SoState state)"""
    return _coin.SoLazyElement_setToDefault(state)

def SoLazyElement_setDiffuse(state, node, numcolors, colors, packer):
    """SoLazyElement_setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
    return _coin.SoLazyElement_setDiffuse(state, node, numcolors, colors, packer)

def SoLazyElement_setTransparency(state, node, numvalues, transparency, packer):
    """SoLazyElement_setTransparency(SoState state, SoNode node, int32_t numvalues, float const * transparency, SoColorPacker packer)"""
    return _coin.SoLazyElement_setTransparency(state, node, numvalues, transparency, packer)

def SoLazyElement_setColorIndices(state, node, numindices, indices):
    """SoLazyElement_setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t const * indices)"""
    return _coin.SoLazyElement_setColorIndices(state, node, numindices, indices)

def SoLazyElement_setAmbient(state, color):
    """SoLazyElement_setAmbient(SoState state, SbColor color)"""
    return _coin.SoLazyElement_setAmbient(state, color)

def SoLazyElement_setEmissive(state, color):
    """SoLazyElement_setEmissive(SoState state, SbColor color)"""
    return _coin.SoLazyElement_setEmissive(state, color)

def SoLazyElement_setSpecular(state, color):
    """SoLazyElement_setSpecular(SoState state, SbColor color)"""
    return _coin.SoLazyElement_setSpecular(state, color)

def SoLazyElement_setShininess(state, value):
    """SoLazyElement_setShininess(SoState state, float value)"""
    return _coin.SoLazyElement_setShininess(state, value)

def SoLazyElement_setColorMaterial(state, value):
    """SoLazyElement_setColorMaterial(SoState state, SbBool value)"""
    return _coin.SoLazyElement_setColorMaterial(state, value)

def SoLazyElement_enableBlending(state, sfactor, dfactor):
    """SoLazyElement_enableBlending(SoState state, int sfactor, int dfactor)"""
    return _coin.SoLazyElement_enableBlending(state, sfactor, dfactor)

def SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor):
    """SoLazyElement_enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
    return _coin.SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor)

def SoLazyElement_disableBlending(state):
    """SoLazyElement_disableBlending(SoState state)"""
    return _coin.SoLazyElement_disableBlending(state)

def SoLazyElement_setLightModel(state, model):
    """SoLazyElement_setLightModel(SoState state, int32_t const model)"""
    return _coin.SoLazyElement_setLightModel(state, model)

def SoLazyElement_setVertexOrdering(state, ordering):
    """SoLazyElement_setVertexOrdering(SoState state, SoLazyElement::VertexOrdering ordering)"""
    return _coin.SoLazyElement_setVertexOrdering(state, ordering)

def SoLazyElement_setBackfaceCulling(state, onoff):
    """SoLazyElement_setBackfaceCulling(SoState state, SbBool onoff)"""
    return _coin.SoLazyElement_setBackfaceCulling(state, onoff)

def SoLazyElement_setTwosideLighting(state, onoff):
    """SoLazyElement_setTwosideLighting(SoState state, SbBool onoff)"""
    return _coin.SoLazyElement_setTwosideLighting(state, onoff)

def SoLazyElement_setShadeModel(state, flatshading):
    """SoLazyElement_setShadeModel(SoState state, SbBool flatshading)"""
    return _coin.SoLazyElement_setShadeModel(state, flatshading)

def SoLazyElement_setGLImageId(state, glimageid, alphatest):
    """SoLazyElement_setGLImageId(SoState state, uint32_t glimageid, SbBool alphatest)"""
    return _coin.SoLazyElement_setGLImageId(state, glimageid, alphatest)

def SoLazyElement_setAlphaTest(state, onoff):
    """SoLazyElement_setAlphaTest(SoState state, SbBool onoff)"""
    return _coin.SoLazyElement_setAlphaTest(state, onoff)

def SoLazyElement_getDiffuse(state, index):
    """SoLazyElement_getDiffuse(SoState state, int index) -> SbColor"""
    return _coin.SoLazyElement_getDiffuse(state, index)

def SoLazyElement_getTransparency(arg2, index):
    """SoLazyElement_getTransparency(SoState arg2, int index) -> float"""
    return _coin.SoLazyElement_getTransparency(arg2, index)

def SoLazyElement_getPackedColors(arg2):
    """SoLazyElement_getPackedColors(SoState arg2) -> uint32_t const *"""
    return _coin.SoLazyElement_getPackedColors(arg2)

def SoLazyElement_getColorIndices(arg2):
    """SoLazyElement_getColorIndices(SoState arg2) -> int32_t const *"""
    return _coin.SoLazyElement_getColorIndices(arg2)

def SoLazyElement_getColorIndex(arg2, num):
    """SoLazyElement_getColorIndex(SoState arg2, int num) -> int32_t"""
    return _coin.SoLazyElement_getColorIndex(arg2, num)

def SoLazyElement_getAmbient(arg2):
    """SoLazyElement_getAmbient(SoState arg2) -> SbColor"""
    return _coin.SoLazyElement_getAmbient(arg2)

def SoLazyElement_getEmissive(arg2):
    """SoLazyElement_getEmissive(SoState arg2) -> SbColor"""
    return _coin.SoLazyElement_getEmissive(arg2)

def SoLazyElement_getSpecular(arg2):
    """SoLazyElement_getSpecular(SoState arg2) -> SbColor"""
    return _coin.SoLazyElement_getSpecular(arg2)

def SoLazyElement_getShininess(arg2):
    """SoLazyElement_getShininess(SoState arg2) -> float"""
    return _coin.SoLazyElement_getShininess(arg2)

def SoLazyElement_getColorMaterial(arg2):
    """SoLazyElement_getColorMaterial(SoState arg2) -> SbBool"""
    return _coin.SoLazyElement_getColorMaterial(arg2)

def SoLazyElement_getBlending(arg2, sfactor, dfactor):
    """SoLazyElement_getBlending(SoState arg2, int & sfactor, int & dfactor) -> SbBool"""
    return _coin.SoLazyElement_getBlending(arg2, sfactor, dfactor)

def SoLazyElement_getAlphaBlending(arg2, sfactor, dfactor):
    """SoLazyElement_getAlphaBlending(SoState arg2, int & sfactor, int & dfactor) -> SbBool"""
    return _coin.SoLazyElement_getAlphaBlending(arg2, sfactor, dfactor)

def SoLazyElement_getLightModel(arg2):
    """SoLazyElement_getLightModel(SoState arg2) -> int32_t"""
    return _coin.SoLazyElement_getLightModel(arg2)

def SoLazyElement_getAlphaTest(state):
    """SoLazyElement_getAlphaTest(SoState state) -> SbBool"""
    return _coin.SoLazyElement_getAlphaTest(state)

def SoLazyElement_getInstance(state):
    """SoLazyElement_getInstance(SoState state) -> SoLazyElement"""
    return _coin.SoLazyElement_getInstance(state)

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(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent):
    """SoLazyElement_setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
    return _coin.SoLazyElement_setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)

def SoLazyElement_getWInstance(state):
    """SoLazyElement_getWInstance(SoState state) -> SoLazyElement"""
    return _coin.SoLazyElement_getWInstance(state)

def SoLazyElement_setTransparencyType(state, type):
    """SoLazyElement_setTransparencyType(SoState state, int32_t type)"""
    return _coin.SoLazyElement_setTransparencyType(state, type)

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__(SoColorPacker 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(SoColorPacker self) -> uint32_t *"""
        return _coin.SoColorPacker_getPackedColors(self)


    def diffuseMatch(self, nodeid):
        """diffuseMatch(SoColorPacker self, uint32_t const nodeid) -> SbBool"""
        return _coin.SoColorPacker_diffuseMatch(self, nodeid)


    def transpMatch(self, nodeid):
        """transpMatch(SoColorPacker self, uint32_t const nodeid) -> SbBool"""
        return _coin.SoColorPacker_transpMatch(self, nodeid)


    def setNodeIds(self, diffuse, transp):
        """setNodeIds(SoColorPacker self, uint32_t const diffuse, uint32_t const transp)"""
        return _coin.SoColorPacker_setNodeIds(self, diffuse, transp)


    def getSize(self):
        """getSize(SoColorPacker self) -> int32_t"""
        return _coin.SoColorPacker_getSize(self)


    def reallocate(self, size):
        """reallocate(SoColorPacker self, int32_t const size)"""
        return _coin.SoColorPacker_reallocate(self, size)


    def getDiffuseId(self):
        """getDiffuseId(SoColorPacker self) -> uint32_t"""
        return _coin.SoColorPacker_getDiffuseId(self)


    def getTranspId(self):
        """getTranspId(SoColorPacker 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(SoLightModel self) -> SoType"""
        return _coin.SoLightModel_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoLightModel 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, action):
        """doAction(SoLightModel self, SoAction action)"""
        return _coin.SoLightModel_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoLightModel self, SoGLRenderAction action)"""
        return _coin.SoLightModel_GLRender(self, action)


    def callback(self, action):
        """callback(SoLightModel self, SoCallbackAction action)"""
        return _coin.SoLightModel_callback(self, action)

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, state):
        """init(SoMaterialBindingElement self, SoState state)"""
        return _coin.SoMaterialBindingElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, SoMaterialBindingElement::Binding const binding)
        set(SoState state, SoMaterialBindingElement::Binding const binding)
        """
        return _coin.SoMaterialBindingElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoMaterialBindingElement::Binding"""
        return _coin.SoMaterialBindingElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoMaterialBindingElement::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, SoMaterialBindingElement::Binding const binding)
    SoMaterialBindingElement_set(SoState state, SoMaterialBindingElement::Binding const binding)
    """
    return _coin.SoMaterialBindingElement_set(*args)

def SoMaterialBindingElement_get(state):
    """SoMaterialBindingElement_get(SoState state) -> SoMaterialBindingElement::Binding"""
    return _coin.SoMaterialBindingElement_get(state)

def SoMaterialBindingElement_getDefault():
    """SoMaterialBindingElement_getDefault() -> SoMaterialBindingElement::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(SoMaterialBinding self) -> SoType"""
        return _coin.SoMaterialBinding_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoMaterialBinding 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, action):
        """doAction(SoMaterialBinding self, SoAction action)"""
        return _coin.SoMaterialBinding_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoMaterialBinding self, SoGLRenderAction action)"""
        return _coin.SoMaterialBinding_GLRender(self, action)


    def callback(self, action):
        """callback(SoMaterialBinding self, SoCallbackAction action)"""
        return _coin.SoMaterialBinding_callback(self, action)


    def pick(self, action):
        """pick(SoMaterialBinding self, SoPickAction action)"""
        return _coin.SoMaterialBinding_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoMaterialBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMaterialBinding_getPrimitiveCount(self, action)

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, state):
        """init(SoNormalBindingElement self, SoState state)"""
        return _coin.SoNormalBindingElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, SoNormalBindingElement::Binding const binding)
        set(SoState state, SoNormalBindingElement::Binding const binding)
        """
        return _coin.SoNormalBindingElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoNormalBindingElement::Binding"""
        return _coin.SoNormalBindingElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoNormalBindingElement::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, SoNormalBindingElement::Binding const binding)
    SoNormalBindingElement_set(SoState state, SoNormalBindingElement::Binding const binding)
    """
    return _coin.SoNormalBindingElement_set(*args)

def SoNormalBindingElement_get(state):
    """SoNormalBindingElement_get(SoState state) -> SoNormalBindingElement::Binding"""
    return _coin.SoNormalBindingElement_get(state)

def SoNormalBindingElement_getDefault():
    """SoNormalBindingElement_getDefault() -> SoNormalBindingElement::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(SoNormalBinding self) -> SoType"""
        return _coin.SoNormalBinding_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoNormalBinding 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, action):
        """doAction(SoNormalBinding self, SoAction action)"""
        return _coin.SoNormalBinding_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoNormalBinding self, SoGLRenderAction action)"""
        return _coin.SoNormalBinding_GLRender(self, action)


    def callback(self, action):
        """callback(SoNormalBinding self, SoCallbackAction action)"""
        return _coin.SoNormalBinding_callback(self, action)


    def pick(self, action):
        """pick(SoNormalBinding self, SoPickAction action)"""
        return _coin.SoNormalBinding_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoNormalBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNormalBinding_getPrimitiveCount(self, action)

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, state):
        """init(SoPickStyleElement self, SoState state)"""
        return _coin.SoPickStyleElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, int32_t const style)
        set(SoState state, SoPickStyleElement::Style const style)
        """
        return _coin.SoPickStyleElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoPickStyleElement::Style"""
        return _coin.SoPickStyleElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoPickStyleElement::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 const style)
    SoPickStyleElement_set(SoState state, SoPickStyleElement::Style const style)
    """
    return _coin.SoPickStyleElement_set(*args)

def SoPickStyleElement_get(state):
    """SoPickStyleElement_get(SoState state) -> SoPickStyleElement::Style"""
    return _coin.SoPickStyleElement_get(state)

def SoPickStyleElement_getDefault():
    """SoPickStyleElement_getDefault() -> SoPickStyleElement::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(SoPickStyle self) -> SoType"""
        return _coin.SoPickStyle_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPickStyle 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, action):
        """doAction(SoPickStyle self, SoAction action)"""
        return _coin.SoPickStyle_doAction(self, action)


    def callback(self, action):
        """callback(SoPickStyle self, SoCallbackAction action)"""
        return _coin.SoPickStyle_callback(self, action)


    def pick(self, action):
        """pick(SoPickStyle self, SoPickAction action)"""
        return _coin.SoPickStyle_pick(self, action)

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, state):
        """init(SoShapeHintsElement self, SoState state)"""
        return _coin.SoShapeHintsElement_init(self, state)


    def push(self, state):
        """push(SoShapeHintsElement self, SoState state)"""
        return _coin.SoShapeHintsElement_push(self, state)


    def pop(self, state, prevtopelement):
        """pop(SoShapeHintsElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoShapeHintsElement_pop(self, state, prevtopelement)


    def matches(self, element):
        """matches(SoShapeHintsElement self, SoElement element) -> SbBool"""
        return _coin.SoShapeHintsElement_matches(self, element)


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


    def set(*args):
        """
        set(SoState state, SoNode node, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
        set(SoState state, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
        """
        return _coin.SoShapeHintsElement_set(*args)

    set = staticmethod(set)

    def get(state, vertexOrdering, shapeType, faceType):
        """get(SoState state, SoShapeHintsElement::VertexOrdering & vertexOrdering, SoShapeHintsElement::ShapeType & shapeType, SoShapeHintsElement::FaceType & faceType)"""
        return _coin.SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType)

    get = staticmethod(get)

    def getVertexOrdering(state):
        """getVertexOrdering(SoState state) -> SoShapeHintsElement::VertexOrdering"""
        return _coin.SoShapeHintsElement_getVertexOrdering(state)

    getVertexOrdering = staticmethod(getVertexOrdering)

    def getShapeType(state):
        """getShapeType(SoState state) -> SoShapeHintsElement::ShapeType"""
        return _coin.SoShapeHintsElement_getShapeType(state)

    getShapeType = staticmethod(getShapeType)

    def getFaceType(state):
        """getFaceType(SoState state) -> SoShapeHintsElement::FaceType"""
        return _coin.SoShapeHintsElement_getFaceType(state)

    getFaceType = staticmethod(getFaceType)

    def getDefaultVertexOrdering():
        """getDefaultVertexOrdering() -> SoShapeHintsElement::VertexOrdering"""
        return _coin.SoShapeHintsElement_getDefaultVertexOrdering()

    getDefaultVertexOrdering = staticmethod(getDefaultVertexOrdering)

    def getDefaultShapeType():
        """getDefaultShapeType() -> SoShapeHintsElement::ShapeType"""
        return _coin.SoShapeHintsElement_getDefaultShapeType()

    getDefaultShapeType = staticmethod(getDefaultShapeType)

    def getDefaultFaceType():
        """getDefaultFaceType() -> SoShapeHintsElement::FaceType"""
        return _coin.SoShapeHintsElement_getDefaultFaceType()

    getDefaultFaceType = staticmethod(getDefaultFaceType)

    def output(self, file):
        """output(SoShapeHintsElement self, FILE * file)"""
        return _coin.SoShapeHintsElement_output(self, file)

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, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
    SoShapeHintsElement_set(SoState state, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
    """
    return _coin.SoShapeHintsElement_set(*args)

def SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType):
    """SoShapeHintsElement_get(SoState state, SoShapeHintsElement::VertexOrdering & vertexOrdering, SoShapeHintsElement::ShapeType & shapeType, SoShapeHintsElement::FaceType & faceType)"""
    return _coin.SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType)

def SoShapeHintsElement_getVertexOrdering(state):
    """SoShapeHintsElement_getVertexOrdering(SoState state) -> SoShapeHintsElement::VertexOrdering"""
    return _coin.SoShapeHintsElement_getVertexOrdering(state)

def SoShapeHintsElement_getShapeType(state):
    """SoShapeHintsElement_getShapeType(SoState state) -> SoShapeHintsElement::ShapeType"""
    return _coin.SoShapeHintsElement_getShapeType(state)

def SoShapeHintsElement_getFaceType(state):
    """SoShapeHintsElement_getFaceType(SoState state) -> SoShapeHintsElement::FaceType"""
    return _coin.SoShapeHintsElement_getFaceType(state)

def SoShapeHintsElement_getDefaultVertexOrdering():
    """SoShapeHintsElement_getDefaultVertexOrdering() -> SoShapeHintsElement::VertexOrdering"""
    return _coin.SoShapeHintsElement_getDefaultVertexOrdering()

def SoShapeHintsElement_getDefaultShapeType():
    """SoShapeHintsElement_getDefaultShapeType() -> SoShapeHintsElement::ShapeType"""
    return _coin.SoShapeHintsElement_getDefaultShapeType()

def SoShapeHintsElement_getDefaultFaceType():
    """SoShapeHintsElement_getDefaultFaceType() -> SoShapeHintsElement::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__(SoSFBool 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(SoSFBool self) -> SoType"""
        return _coin.SoSFBool_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBool self, SoField field)"""
        return _coin.SoSFBool_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBool self, SoField field) -> SbBool"""
        return _coin.SoSFBool_isSame(self, field)


    def getValue(self):
        """getValue(SoSFBool self) -> SbBool"""
        return _coin.SoSFBool_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFBool self, SoSFBool field) -> int"""
        return _coin.SoSFBool___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBool self, SoSFBool field) -> int"""
        return _coin.SoSFBool___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBool self, SbBool newvalue)
        setValue(SoSFBool 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(SoShapeHints self) -> SoType"""
        return _coin.SoShapeHints_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoShapeHints 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, action):
        """doAction(SoShapeHints self, SoAction action)"""
        return _coin.SoShapeHints_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoShapeHints self, SoGLRenderAction action)"""
        return _coin.SoShapeHints_GLRender(self, action)


    def callback(self, action):
        """callback(SoShapeHints self, SoCallbackAction action)"""
        return _coin.SoShapeHints_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoShapeHints self, SoGetBoundingBoxAction action)"""
        return _coin.SoShapeHints_getBoundingBox(self, action)


    def pick(self, action):
        """pick(SoShapeHints self, SoPickAction action)"""
        return _coin.SoShapeHints_pick(self, action)

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(SoTexture 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, action):
        """doAction(SoTexture self, SoAction action)"""
        return _coin.SoTexture_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTexture self, SoGLRenderAction action)"""
        return _coin.SoTexture_GLRender(self, action)


    def callback(self, action):
        """callback(SoTexture self, SoCallbackAction action)"""
        return _coin.SoTexture_callback(self, action)

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__(SoSFImage 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(SoSFImage self) -> SoType"""
        return _coin.SoSFImage_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFImage self, SoField field)"""
        return _coin.SoSFImage_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFImage self, SoField field) -> SbBool"""
        return _coin.SoSFImage_isSame(self, field)

    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(SoSFImage self) -> unsigned char const
        getValue(SoSFImage self) -> SbImage
        """
        return _coin.SoSFImage_getValue(self, *args)


    def __eq__(self, field):
        """__eq__(SoSFImage self, SoSFImage field) -> int"""
        return _coin.SoSFImage___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFImage self, SoSFImage field) -> int"""
        return _coin.SoSFImage___ne__(self, field)


    def startEditing(self):
        """startEditing(SoSFImage self) -> unsigned char *"""
        return _coin.SoSFImage_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoSFImage self)"""
        return _coin.SoSFImage_finishEditing(self)


    def setSubValue(self, dims, offset, pixels):
        """setSubValue(SoSFImage self, SbVec2s dims, SbVec2s offset, unsigned char * pixels)"""
        return _coin.SoSFImage_setSubValue(self, dims, offset, pixels)


    def setSubValues(self, dims, offsets, num, pixelblocks):
        """setSubValues(SoSFImage self, SbVec2s dims, SbVec2s offsets, int num, unsigned char ** pixelblocks)"""
        return _coin.SoSFImage_setSubValues(self, dims, offsets, num, pixelblocks)


    def getSubTexture(self, idx, dims, offset):
        """getSubTexture(SoSFImage self, int idx, SbVec2s dims, SbVec2s offset) -> unsigned char *"""
        return _coin.SoSFImage_getSubTexture(self, idx, dims, offset)


    def hasSubTextures(self, numsubtextures):
        """hasSubTextures(SoSFImage self, int & numsubtextures) -> SbBool"""
        return _coin.SoSFImage_hasSubTextures(self, numsubtextures)


    def setNeverWrite(self, flag):
        """setNeverWrite(SoSFImage self, SbBool flag)"""
        return _coin.SoSFImage_setNeverWrite(self, flag)


    def isNeverWrite(self):
        """isNeverWrite(SoSFImage self) -> SbBool"""
        return _coin.SoSFImage_isNeverWrite(self)


    def hasTransparency(self):
        """hasTransparency(SoSFImage self) -> SbBool"""
        return _coin.SoSFImage_hasTransparency(self)


    def setValue(self, *args):
        """
        setValue(SoSFImage self, SbVec2s size, int const nc, unsigned char const * pixels, SoSFImage::CopyPolicy copypolicy)
        setValue(SoSFImage self, SbVec2s size, int const nc, unsigned char const * pixels)
        setValue(SoSFImage self, SbVec2s size, int const nc, PyObject * pixels)
        setValue(SoSFImage 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__(SoSFString 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(SoSFString self) -> SoType"""
        return _coin.SoSFString_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFString self, SoField field)"""
        return _coin.SoSFString_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFString self, SoField field) -> SbBool"""
        return _coin.SoSFString_isSame(self, field)


    def getValue(self):
        """getValue(SoSFString self) -> SbString"""
        return _coin.SoSFString_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFString self, SoSFString field) -> int"""
        return _coin.SoSFString___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFString self, SoSFString field) -> int"""
        return _coin.SoSFString___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFString self, SbString newvalue)
        setValue(SoSFString self, char const * str)
        setValue(SoSFString 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__(SoSFColor 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(SoSFColor self) -> SoType"""
        return _coin.SoSFColor_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFColor self, SoField field)"""
        return _coin.SoSFColor_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFColor self, SoField field) -> SbBool"""
        return _coin.SoSFColor_isSame(self, field)


    def getValue(self):
        """getValue(SoSFColor self) -> SbColor"""
        return _coin.SoSFColor_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFColor self, SoSFColor field) -> int"""
        return _coin.SoSFColor___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFColor self, SoSFColor field) -> int"""
        return _coin.SoSFColor___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setHSVValue(self, *args):
        """
        setHSVValue(SoSFColor self, float h, float s, float v)
        setHSVValue(SoSFColor self, float const [3] hsv)
        """
        return _coin.SoSFColor_setHSVValue(self, *args)


    def setValue(self, *args):
        """
        setValue(SoSFColor self, SbColor newvalue)
        setValue(SoSFColor self, SbVec3f vec)
        setValue(SoSFColor self, float red, float green, float blue)
        setValue(SoSFColor self, float const [3] rgb)
        setValue(SoSFColor 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, state):
        """init(SoReplacedElement self, SoState state)"""
        return _coin.SoReplacedElement_init(self, state)


    def matches(self, element):
        """matches(SoReplacedElement self, SoElement element) -> SbBool"""
        return _coin.SoReplacedElement_matches(self, element)


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


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


    def output(self, file):
        """output(SoReplacedElement self, FILE * file)"""
        return _coin.SoReplacedElement_output(self, file)

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__(SbVec3s self) -> SbVec3s
        __init__(SbVec3s self, short const [3] v) -> SbVec3s
        __init__(SbVec3s self, short x, short y, short z) -> SbVec3s
        __init__(SbVec3s self, SbVec3us const & v) -> SbVec3s
        __init__(SbVec3s self, SbVec3b v) -> SbVec3s
        __init__(SbVec3s self, SbVec3i32 v) -> SbVec3s
        __init__(SbVec3s self, SbVec3f v) -> SbVec3s
        __init__(SbVec3s self, SbVec3d v) -> SbVec3s
        """
        this = _coin.new_SbVec3s(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec3s self, short const [3] v) -> SbVec3s
        setValue(SbVec3s self, short x, short y, short z) -> SbVec3s
        setValue(SbVec3s self, SbVec3us const & v) -> SbVec3s
        setValue(SbVec3s self, SbVec3b v) -> SbVec3s
        setValue(SbVec3s self, SbVec3i32 v) -> SbVec3s
        setValue(SbVec3s self, SbVec3f v) -> SbVec3s
        setValue(SbVec3s self, SbVec3d v) -> SbVec3s
        """
        return _coin.SbVec3s_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec3s self) -> short const
        getValue(SbVec3s self)
        """
        return _coin.SbVec3s_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec3s self, SbVec3s v) -> int32_t"""
        return _coin.SbVec3s_dot(self, v)


    def negate(self):
        """negate(SbVec3s self)"""
        return _coin.SbVec3s_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec3s self, SbVec3s v) -> SbVec3s"""
        return _coin.SbVec3s___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec3s self, SbVec3s v) -> SbVec3s"""
        return _coin.SbVec3s___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec3s self) -> SbVec3s"""
        return _coin.SbVec3s___neg__(self)


    def output(self, fp):
        """output(SbVec3s self, FILE * fp)"""
        return _coin.SbVec3s_output(self, fp)


    def __add__(self, u):
        """__add__(SbVec3s self, SbVec3s u) -> SbVec3s"""
        return _coin.SbVec3s___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbVec3s self, SbVec3s u) -> SbVec3s"""
        return _coin.SbVec3s___sub__(self, u)


    def __mul__(self, d):
        """__mul__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___mul__(self, d)


    def __rmul__(self, d):
        """__rmul__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbVec3s self, SbVec3s u) -> int"""
        return _coin.SbVec3s___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbVec3s self, SbVec3s u) -> int"""
        return _coin.SbVec3s___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbVec3s self, int i) -> short"""
        return _coin.SbVec3s___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SbVec3s self, int i, short value)"""
        return _coin.SbVec3s___setitem__(self, i, value)


    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, state):
        """init(SoTextureImageElement self, SoState state)"""
        return _coin.SoTextureImageElement_init(self, state)


    def setDefault(state, node):
        """setDefault(SoState state, SoNode node)"""
        return _coin.SoTextureImageElement_setDefault(state, node)

    setDefault = staticmethod(setDefault)

    def set(*args):
        """
        set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const wrapR, int const model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Model const model, SbColor blendColor)
        set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Wrap const wrapR, SoTextureImageElement::Model const model, SbColor blendColor)
        """
        return _coin.SoTextureImageElement_set(*args)

    set = staticmethod(set)

    def get(*args):
        """
        get(SoState state, SbVec2s size, int & numComponents, SoTextureImageElement::Wrap & wrapS, SoTextureImageElement::Wrap & wrapT, SoTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
        get(SoState state, SbVec3s size, int & numComponents, SoTextureImageElement::Wrap & wrapS, SoTextureImageElement::Wrap & wrapT, SoTextureImageElement::Wrap & wrapR, SoTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
        get(SoState state, SbVec2s size, int & numComponents, int & wrapS, int & wrapT, int & model, SbColor blendColor) -> unsigned char const
        get(SoState state, SbVec3s size, int & numComponents, int & wrapS, int & wrapT, int & wrapR, int & model, SbColor blendColor) -> unsigned char const *
        """
        return _coin.SoTextureImageElement_get(*args)

    get = staticmethod(get)

    def getBlendColor(state):
        """getBlendColor(SoState state) -> SbColor"""
        return _coin.SoTextureImageElement_getBlendColor(state)

    getBlendColor = staticmethod(getBlendColor)

    def getImage(*args):
        """
        getImage(SoState state, SbVec2s size, int & numComponents) -> unsigned char const
        getImage(SoState state, SbVec3s size, int & numComponents) -> unsigned char const *
        """
        return _coin.SoTextureImageElement_getImage(*args)

    getImage = staticmethod(getImage)

    def getModel(state):
        """getModel(SoState state) -> SoTextureImageElement::Model"""
        return _coin.SoTextureImageElement_getModel(state)

    getModel = staticmethod(getModel)

    def getWrapS(state):
        """getWrapS(SoState state) -> SoTextureImageElement::Wrap"""
        return _coin.SoTextureImageElement_getWrapS(state)

    getWrapS = staticmethod(getWrapS)

    def getWrapT(state):
        """getWrapT(SoState state) -> SoTextureImageElement::Wrap"""
        return _coin.SoTextureImageElement_getWrapT(state)

    getWrapT = staticmethod(getWrapT)

    def getWrapR(state):
        """getWrapR(SoState state) -> SoTextureImageElement::Wrap"""
        return _coin.SoTextureImageElement_getWrapR(state)

    getWrapR = staticmethod(getWrapR)

    def containsTransparency(state):
        """containsTransparency(SoState state) -> SbBool"""
        return _coin.SoTextureImageElement_containsTransparency(state)

    containsTransparency = staticmethod(containsTransparency)

    def getDefault(*args):
        """
        getDefault(SbVec2s size, int & numComponents) -> unsigned char const
        getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
        """
        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(state, node):
    """SoTextureImageElement_setDefault(SoState state, SoNode node)"""
    return _coin.SoTextureImageElement_setDefault(state, node)

def SoTextureImageElement_set(*args):
    """
    set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const model, SbColor blendColor)
    set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const wrapR, int const model, SbColor blendColor)
    set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Model const model, SbColor blendColor)
    SoTextureImageElement_set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Wrap const wrapR, SoTextureImageElement::Model const model, SbColor blendColor)
    """
    return _coin.SoTextureImageElement_set(*args)

def SoTextureImageElement_get(*args):
    """
    get(SoState state, SbVec2s size, int & numComponents, SoTextureImageElement::Wrap & wrapS, SoTextureImageElement::Wrap & wrapT, SoTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
    get(SoState state, SbVec3s size, int & numComponents, SoTextureImageElement::Wrap & wrapS, SoTextureImageElement::Wrap & wrapT, SoTextureImageElement::Wrap & wrapR, SoTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
    get(SoState state, SbVec2s size, int & numComponents, int & wrapS, int & wrapT, int & model, SbColor blendColor) -> unsigned char const
    SoTextureImageElement_get(SoState state, SbVec3s size, int & numComponents, int & wrapS, int & wrapT, int & wrapR, int & model, SbColor blendColor) -> unsigned char const *
    """
    return _coin.SoTextureImageElement_get(*args)

def SoTextureImageElement_getBlendColor(state):
    """SoTextureImageElement_getBlendColor(SoState state) -> SbColor"""
    return _coin.SoTextureImageElement_getBlendColor(state)

def SoTextureImageElement_getImage(*args):
    """
    getImage(SoState state, SbVec2s size, int & numComponents) -> unsigned char const
    SoTextureImageElement_getImage(SoState state, SbVec3s size, int & numComponents) -> unsigned char const *
    """
    return _coin.SoTextureImageElement_getImage(*args)

def SoTextureImageElement_getModel(state):
    """SoTextureImageElement_getModel(SoState state) -> SoTextureImageElement::Model"""
    return _coin.SoTextureImageElement_getModel(state)

def SoTextureImageElement_getWrapS(state):
    """SoTextureImageElement_getWrapS(SoState state) -> SoTextureImageElement::Wrap"""
    return _coin.SoTextureImageElement_getWrapS(state)

def SoTextureImageElement_getWrapT(state):
    """SoTextureImageElement_getWrapT(SoState state) -> SoTextureImageElement::Wrap"""
    return _coin.SoTextureImageElement_getWrapT(state)

def SoTextureImageElement_getWrapR(state):
    """SoTextureImageElement_getWrapR(SoState state) -> SoTextureImageElement::Wrap"""
    return _coin.SoTextureImageElement_getWrapR(state)

def SoTextureImageElement_containsTransparency(state):
    """SoTextureImageElement_containsTransparency(SoState state) -> SbBool"""
    return _coin.SoTextureImageElement_containsTransparency(state)

def SoTextureImageElement_getDefault(*args):
    """
    getDefault(SbVec2s size, int & numComponents) -> unsigned char const
    SoTextureImageElement_getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
    """
    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(SoTexture2 self) -> SoType"""
        return _coin.SoTexture2_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTexture2 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, action):
        """doAction(SoTexture2 self, SoAction action)"""
        return _coin.SoTexture2_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTexture2 self, SoGLRenderAction action)"""
        return _coin.SoTexture2_GLRender(self, action)


    def callback(self, action):
        """callback(SoTexture2 self, SoCallbackAction action)"""
        return _coin.SoTexture2_callback(self, action)


    def rayPick(self, action):
        """rayPick(SoTexture2 self, SoRayPickAction action)"""
        return _coin.SoTexture2_rayPick(self, action)


    def readImage(fname, w, h, nc, bytes):
        """readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
        return _coin.SoTexture2_readImage(fname, w, h, nc, bytes)

    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(fname, w, h, nc, bytes):
    """SoTexture2_readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
    return _coin.SoTexture2_readImage(fname, w, h, nc, bytes)

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, state):
        """init(SoTextureCoordinateBindingElement self, SoState state)"""
        return _coin.SoTextureCoordinateBindingElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, SoTextureCoordinateBindingElement::Binding const binding)
        set(SoState state, SoTextureCoordinateBindingElement::Binding const binding)
        """
        return _coin.SoTextureCoordinateBindingElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoTextureCoordinateBindingElement::Binding"""
        return _coin.SoTextureCoordinateBindingElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoTextureCoordinateBindingElement::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, SoTextureCoordinateBindingElement::Binding const binding)
    SoTextureCoordinateBindingElement_set(SoState state, SoTextureCoordinateBindingElement::Binding const binding)
    """
    return _coin.SoTextureCoordinateBindingElement_set(*args)

def SoTextureCoordinateBindingElement_get(state):
    """SoTextureCoordinateBindingElement_get(SoState state) -> SoTextureCoordinateBindingElement::Binding"""
    return _coin.SoTextureCoordinateBindingElement_get(state)

def SoTextureCoordinateBindingElement_getDefault():
    """SoTextureCoordinateBindingElement_getDefault() -> SoTextureCoordinateBindingElement::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(SoTextureCoordinateBinding self) -> SoType"""
        return _coin.SoTextureCoordinateBinding_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateBinding 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, action):
        """doAction(SoTextureCoordinateBinding self, SoAction action)"""
        return _coin.SoTextureCoordinateBinding_doAction(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateBinding self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateBinding_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateBinding self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateBinding_GLRender(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateBinding self, SoPickAction action)"""
        return _coin.SoTextureCoordinateBinding_pick(self, action)

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(SoTransformation 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(SoUnits self) -> SoType"""
        return _coin.SoUnits_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoUnits 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, action):
        """doAction(SoUnits self, SoAction action)"""
        return _coin.SoUnits_doAction(self, action)


    def callback(self, action):
        """callback(SoUnits self, SoCallbackAction action)"""
        return _coin.SoUnits_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoUnits self, SoGetBoundingBoxAction action)"""
        return _coin.SoUnits_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoUnits self, SoGetMatrixAction action)"""
        return _coin.SoUnits_getMatrix(self, action)


    def GLRender(self, action):
        """GLRender(SoUnits self, SoGLRenderAction action)"""
        return _coin.SoUnits_GLRender(self, action)


    def pick(self, action):
        """pick(SoUnits self, SoPickAction action)"""
        return _coin.SoUnits_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoUnits self, SoGetPrimitiveCountAction action)"""
        return _coin.SoUnits_getPrimitiveCount(self, action)

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(SoCallbackAction self) -> SoType"""
        return _coin.SoCallbackAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoCallbackAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoCallbackAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoCallbackAction self) -> SoCallbackAction
        __init__(SoCallbackAction 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, vp):
        """setViewportRegion(SoCallbackAction self, SbViewportRegion vp)"""
        return _coin.SoCallbackAction_setViewportRegion(self, vp)

    CONTINUE = _coin.SoCallbackAction_CONTINUE
    ABORT = _coin.SoCallbackAction_ABORT
    PRUNE = _coin.SoCallbackAction_PRUNE

    def getDecimationType(self):
        """getDecimationType(SoCallbackAction self) -> SoDecimationTypeElement::Type"""
        return _coin.SoCallbackAction_getDecimationType(self)


    def getDecimationPercentage(self):
        """getDecimationPercentage(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getDecimationPercentage(self)


    def getComplexity(self):
        """getComplexity(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getComplexity(self)


    def getComplexityType(self):
        """getComplexityType(SoCallbackAction self) -> SoComplexity::Type"""
        return _coin.SoCallbackAction_getComplexityType(self)


    def getNumCoordinates(self):
        """getNumCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumCoordinates(self)


    def getCoordinate3(self, index):
        """getCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getCoordinate3(self, index)


    def getCoordinate4(self, index):
        """getCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"""
        return _coin.SoCallbackAction_getCoordinate4(self, index)


    def getDrawStyle(self):
        """getDrawStyle(SoCallbackAction self) -> SoDrawStyle::Style"""
        return _coin.SoCallbackAction_getDrawStyle(self)


    def getLinePattern(self):
        """getLinePattern(SoCallbackAction self) -> unsigned short"""
        return _coin.SoCallbackAction_getLinePattern(self)


    def getLineWidth(self):
        """getLineWidth(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getLineWidth(self)


    def getPointSize(self):
        """getPointSize(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getPointSize(self)


    def getFontName(self):
        """getFontName(SoCallbackAction self) -> SbName"""
        return _coin.SoCallbackAction_getFontName(self)


    def getFontSize(self):
        """getFontSize(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getFontSize(self)


    def getLightModel(self):
        """getLightModel(SoCallbackAction self) -> SoLightModel::Model"""
        return _coin.SoCallbackAction_getLightModel(self)


    def getLightAttenuation(self):
        """getLightAttenuation(SoCallbackAction self) -> SbVec3f"""
        return _coin.SoCallbackAction_getLightAttenuation(self)


    def getMaterialBinding(self):
        """getMaterialBinding(SoCallbackAction self) -> SoMaterialBinding::Binding"""
        return _coin.SoCallbackAction_getMaterialBinding(self)


    def getNumNormals(self):
        """getNumNormals(SoCallbackAction self) -> uint32_t"""
        return _coin.SoCallbackAction_getNumNormals(self)


    def getNormal(self, index):
        """getNormal(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getNormal(self, index)


    def getNormalBinding(self):
        """getNormalBinding(SoCallbackAction self) -> SoNormalBinding::Binding"""
        return _coin.SoCallbackAction_getNormalBinding(self)


    def getNumProfileCoordinates(self):
        """getNumProfileCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumProfileCoordinates(self)


    def getProfileCoordinate2(self, index):
        """getProfileCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"""
        return _coin.SoCallbackAction_getProfileCoordinate2(self, index)


    def getProfileCoordinate3(self, index):
        """getProfileCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getProfileCoordinate3(self, index)


    def getProfile(self):
        """getProfile(SoCallbackAction self) -> SoNodeList"""
        return _coin.SoCallbackAction_getProfile(self)


    def getVertexOrdering(self):
        """getVertexOrdering(SoCallbackAction self) -> SoShapeHints::VertexOrdering"""
        return _coin.SoCallbackAction_getVertexOrdering(self)


    def getShapeType(self):
        """getShapeType(SoCallbackAction self) -> SoShapeHints::ShapeType"""
        return _coin.SoCallbackAction_getShapeType(self)


    def getFaceType(self):
        """getFaceType(SoCallbackAction self) -> SoShapeHints::FaceType"""
        return _coin.SoCallbackAction_getFaceType(self)


    def getCreaseAngle(self):
        """getCreaseAngle(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getCreaseAngle(self)


    def getNumTextureCoordinates(self):
        """getNumTextureCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumTextureCoordinates(self)


    def getTextureCoordinate2(self, index):
        """getTextureCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"""
        return _coin.SoCallbackAction_getTextureCoordinate2(self, index)


    def getTextureCoordinate3(self, index):
        """getTextureCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getTextureCoordinate3(self, index)


    def getTextureCoordinate4(self, index):
        """getTextureCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"""
        return _coin.SoCallbackAction_getTextureCoordinate4(self, index)


    def getTextureCoordinateBinding(self):
        """getTextureCoordinateBinding(SoCallbackAction self) -> SoTextureCoordinateBinding::Binding"""
        return _coin.SoCallbackAction_getTextureCoordinateBinding(self)


    def getTextureBlendColor(self):
        """getTextureBlendColor(SoCallbackAction self) -> SbColor"""
        return _coin.SoCallbackAction_getTextureBlendColor(self)


    def getTextureImage(self, *args):
        """
        getTextureImage(SoCallbackAction self, SbVec2s size, int & numcomps) -> unsigned char const
        getTextureImage(SoCallbackAction self, SbVec3s size, int & numcomps) -> unsigned char const *
        """
        return _coin.SoCallbackAction_getTextureImage(self, *args)


    def getTextureMatrix(self):
        """getTextureMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getTextureMatrix(self)


    def getTextureModel(self):
        """getTextureModel(SoCallbackAction self) -> SoTexture2::Model"""
        return _coin.SoCallbackAction_getTextureModel(self)


    def getTextureWrapS(self):
        """getTextureWrapS(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapS(self)


    def getTextureWrapT(self):
        """getTextureWrapT(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapT(self)


    def getTextureWrapR(self):
        """getTextureWrapR(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapR(self)


    def getModelMatrix(self):
        """getModelMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getModelMatrix(self)


    def getUnits(self):
        """getUnits(SoCallbackAction self) -> SoUnits::Units"""
        return _coin.SoCallbackAction_getUnits(self)


    def getFocalDistance(self):
        """getFocalDistance(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getFocalDistance(self)


    def getProjectionMatrix(self):
        """getProjectionMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getProjectionMatrix(self)


    def getViewingMatrix(self):
        """getViewingMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getViewingMatrix(self)


    def getViewVolume(self):
        """getViewVolume(SoCallbackAction self) -> SbViewVolume"""
        return _coin.SoCallbackAction_getViewVolume(self)


    def getViewportRegion(self):
        """getViewportRegion(SoCallbackAction self) -> SbViewportRegion"""
        return _coin.SoCallbackAction_getViewportRegion(self)


    def getPickStyle(self):
        """getPickStyle(SoCallbackAction self) -> SoPickStyle::Style"""
        return _coin.SoCallbackAction_getPickStyle(self)


    def getSwitch(self):
        """getSwitch(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getSwitch(self)


    def getCurrentResponse(self):
        """getCurrentResponse(SoCallbackAction self) -> SoCallbackAction::Response"""
        return _coin.SoCallbackAction_getCurrentResponse(self)


    def invokePreCallbacks(self, node):
        """invokePreCallbacks(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_invokePreCallbacks(self, node)


    def invokePostCallbacks(self, node):
        """invokePostCallbacks(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_invokePostCallbacks(self, node)


    def invokeTriangleCallbacks(self, shape, v1, v2, v3):
        """invokeTriangleCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2, SoPrimitiveVertex v3)"""
        return _coin.SoCallbackAction_invokeTriangleCallbacks(self, shape, v1, v2, v3)


    def invokeLineSegmentCallbacks(self, shape, v1, v2):
        """invokeLineSegmentCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2)"""
        return _coin.SoCallbackAction_invokeLineSegmentCallbacks(self, shape, v1, v2)


    def invokePointCallbacks(self, shape, v):
        """invokePointCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v)"""
        return _coin.SoCallbackAction_invokePointCallbacks(self, shape, v)


    def shouldGeneratePrimitives(self, shape):
        """shouldGeneratePrimitives(SoCallbackAction self, SoShape shape) -> SbBool"""
        return _coin.SoCallbackAction_shouldGeneratePrimitives(self, shape)


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


    def setCurrentNode(self, node):
        """setCurrentNode(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_setCurrentNode(self, node)


    def setCallbackAll(self, callbackall):
        """setCallbackAll(SoCallbackAction self, SbBool callbackall)"""
        return _coin.SoCallbackAction_setCallbackAll(self, callbackall)


    def isCallbackAll(self):
        """isCallbackAll(SoCallbackAction self) -> SbBool"""
        return _coin.SoCallbackAction_isCallbackAll(self)


    def getMaterial(self, index=0):
        """
        getMaterial(SoCallbackAction self, int const index=0) -> PyObject
        getMaterial(SoCallbackAction self) -> PyObject *
        """
        return _coin.SoCallbackAction_getMaterial(self, index)


    def addPreCallback(self, *args):
        """
        addPreCallback(SoCallbackAction self, SoType type, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
        addPreCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPreCallback(self, *args)


    def addPostCallback(self, *args):
        """
        addPostCallback(SoCallbackAction self, SoType type, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
        addPostCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPostCallback(self, *args)


    def addPreTailCallback(self, *args):
        """
        addPreTailCallback(SoCallbackAction self, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
        addPreTailCallback(SoCallbackAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPreTailCallback(self, *args)


    def addPostTailCallback(self, *args):
        """
        addPostTailCallback(SoCallbackAction self, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
        addPostTailCallback(SoCallbackAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPostTailCallback(self, *args)


    def addTriangleCallback(self, *args):
        """
        addTriangleCallback(SoCallbackAction self, SoType type, SoTriangleCB * cb, void * userdata)
        addTriangleCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addTriangleCallback(self, *args)


    def addLineSegmentCallback(self, *args):
        """
        addLineSegmentCallback(SoCallbackAction self, SoType type, SoLineSegmentCB * cb, void * userdata)
        addLineSegmentCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addLineSegmentCallback(self, *args)


    def addPointCallback(self, *args):
        """
        addPointCallback(SoCallbackAction self, SoType type, SoPointCB * cb, void * userdata)
        addPointCallback(SoCallbackAction 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(type, method):
    """SoCallbackAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoCallbackAction_addMethod(type, method)

def SoCallbackAction_enableElement(type, stackindex):
    """SoCallbackAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoCallbackAction_enableElement(type, stackindex)

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__(SbVec2f self) -> SbVec2f
        __init__(SbVec2f self, float const [2] v) -> SbVec2f
        __init__(SbVec2f self, float x, float y) -> SbVec2f
        __init__(SbVec2f self, SbVec2d v) -> SbVec2f
        __init__(SbVec2f self, SbVec2b v) -> SbVec2f
        __init__(SbVec2f self, SbVec2s v) -> SbVec2f
        __init__(SbVec2f self, SbVec2i32 v) -> SbVec2f
        """
        this = _coin.new_SbVec2f(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec2f self, float const [2] v) -> SbVec2f
        setValue(SbVec2f self, float x, float y) -> SbVec2f
        setValue(SbVec2f self, SbVec2d v) -> SbVec2f
        setValue(SbVec2f self, SbVec2b v) -> SbVec2f
        setValue(SbVec2f self, SbVec2s v) -> SbVec2f
        setValue(SbVec2f self, SbVec2i32 v) -> SbVec2f
        """
        return _coin.SbVec2f_setValue(self, *args)


    def getValue(self):
        """getValue(SbVec2f self)"""
        return _coin.SbVec2f_getValue(self)


    def dot(self, v):
        """dot(SbVec2f self, SbVec2f v) -> float"""
        return _coin.SbVec2f_dot(self, v)


    def equals(self, v, tolerance):
        """equals(SbVec2f self, SbVec2f v, float tolerance) -> SbBool"""
        return _coin.SbVec2f_equals(self, v, tolerance)


    def length(self):
        """length(SbVec2f self) -> float"""
        return _coin.SbVec2f_length(self)


    def sqrLength(self):
        """sqrLength(SbVec2f self) -> float"""
        return _coin.SbVec2f_sqrLength(self)


    def negate(self):
        """negate(SbVec2f self)"""
        return _coin.SbVec2f_negate(self)


    def normalize(self):
        """normalize(SbVec2f self) -> float"""
        return _coin.SbVec2f_normalize(self)


    def __imul__(self, d):
        """__imul__(SbVec2f self, float d) -> SbVec2f"""
        return _coin.SbVec2f___imul__(self, d)


    def __idiv__(self, d):
        """__idiv__(SbVec2f self, float d) -> SbVec2f"""
        return _coin.SbVec2f___idiv__(self, d)


    def __iadd__(self, v):
        """__iadd__(SbVec2f self, SbVec2f v) -> SbVec2f"""
        return _coin.SbVec2f___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec2f self, SbVec2f v) -> SbVec2f"""
        return _coin.SbVec2f___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec2f self) -> SbVec2f"""
        return _coin.SbVec2f___neg__(self)


    def output(self, fp):
        """output(SbVec2f self, FILE * fp)"""
        return _coin.SbVec2f_output(self, fp)


    def __add__(self, u):
        """__add__(SbVec2f self, SbVec2f u) -> SbVec2f"""
        return _coin.SbVec2f___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbVec2f self, SbVec2f u) -> SbVec2f"""
        return _coin.SbVec2f___sub__(self, u)


    def __mul__(self, d):
        """__mul__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___mul__(self, d)


    def __rmul__(self, d):
        """__rmul__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbVec2f self, SbVec2f u) -> int"""
        return _coin.SbVec2f___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbVec2f self, SbVec2f u) -> int"""
        return _coin.SbVec2f___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbVec2f self, int i) -> float"""
        return _coin.SbVec2f___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SbVec2f self, int i, float value)"""
        return _coin.SbVec2f___setitem__(self, i, value)


    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__(SbViewportRegion self) -> SbViewportRegion
        __init__(SbViewportRegion self, short width, short height) -> SbViewportRegion
        __init__(SbViewportRegion self, SbVec2s winSize) -> SbViewportRegion
        __init__(SbViewportRegion self, SbViewportRegion vpReg) -> SbViewportRegion
        """
        this = _coin.new_SbViewportRegion(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setWindowSize(self, *args):
        """
        setWindowSize(SbViewportRegion self, short width, short height)
        setWindowSize(SbViewportRegion self, SbVec2s winSize)
        """
        return _coin.SbViewportRegion_setWindowSize(self, *args)


    def setViewport(self, *args):
        """
        setViewport(SbViewportRegion self, float left, float bottom, float width, float height)
        setViewport(SbViewportRegion self, SbVec2f origin, SbVec2f size)
        """
        return _coin.SbViewportRegion_setViewport(self, *args)


    def setViewportPixels(self, *args):
        """
        setViewportPixels(SbViewportRegion self, short left, short bottom, short width, short height)
        setViewportPixels(SbViewportRegion self, SbVec2s origin, SbVec2s size)
        """
        return _coin.SbViewportRegion_setViewportPixels(self, *args)


    def getWindowSize(self):
        """getWindowSize(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getWindowSize(self)


    def getViewportOrigin(self):
        """getViewportOrigin(SbViewportRegion self) -> SbVec2f"""
        return _coin.SbViewportRegion_getViewportOrigin(self)


    def getViewportOriginPixels(self):
        """getViewportOriginPixels(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getViewportOriginPixels(self)


    def getViewportSize(self):
        """getViewportSize(SbViewportRegion self) -> SbVec2f"""
        return _coin.SbViewportRegion_getViewportSize(self)


    def getViewportSizePixels(self):
        """getViewportSizePixels(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getViewportSizePixels(self)


    def getViewportAspectRatio(self):
        """getViewportAspectRatio(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getViewportAspectRatio(self)


    def scaleWidth(self, ratio):
        """scaleWidth(SbViewportRegion self, float ratio)"""
        return _coin.SbViewportRegion_scaleWidth(self, ratio)


    def scaleHeight(self, ratio):
        """scaleHeight(SbViewportRegion self, float ratio)"""
        return _coin.SbViewportRegion_scaleHeight(self, ratio)


    def setPixelsPerInch(self, ppi):
        """setPixelsPerInch(SbViewportRegion self, float ppi)"""
        return _coin.SbViewportRegion_setPixelsPerInch(self, ppi)


    def getPixelsPerInch(self):
        """getPixelsPerInch(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getPixelsPerInch(self)


    def getPixelsPerPoint(self):
        """getPixelsPerPoint(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getPixelsPerPoint(self)


    def output(self, file):
        """output(SbViewportRegion self, FILE * file)"""
        return _coin.SbViewportRegion_output(self, file)


    def __eq__(self, u):
        """__eq__(SbViewportRegion self, SbViewportRegion u) -> int"""
        return _coin.SbViewportRegion___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbViewportRegion self, SbViewportRegion u) -> int"""
        return _coin.SbViewportRegion___ne__(self, u)

    __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(SoGLRenderAction self) -> SoType"""
        return _coin.SoGLRenderAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGLRenderAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoGLRenderAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self, viewportregion):
        """__init__(SoGLRenderAction self, SbViewportRegion viewportregion) -> SoGLRenderAction"""
        this = _coin.new_SoGLRenderAction(viewportregion)
        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, newregion):
        """setViewportRegion(SoGLRenderAction self, SbViewportRegion newregion)"""
        return _coin.SoGLRenderAction_setViewportRegion(self, newregion)


    def getViewportRegion(self):
        """getViewportRegion(SoGLRenderAction self) -> SbViewportRegion"""
        return _coin.SoGLRenderAction_getViewportRegion(self)


    def setUpdateArea(self, origin, size):
        """setUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLRenderAction_setUpdateArea(self, origin, size)


    def getUpdateArea(self, origin, size):
        """getUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLRenderAction_getUpdateArea(self, origin, size)


    def getAbortCallback(self, func_out, userdata_out):
        """getAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *& func_out, void *& userdata_out)"""
        return _coin.SoGLRenderAction_getAbortCallback(self, func_out, userdata_out)


    def setTransparencyType(self, type):
        """setTransparencyType(SoGLRenderAction self, SoGLRenderAction::TransparencyType const type)"""
        return _coin.SoGLRenderAction_setTransparencyType(self, type)


    def getTransparencyType(self):
        """getTransparencyType(SoGLRenderAction self) -> SoGLRenderAction::TransparencyType"""
        return _coin.SoGLRenderAction_getTransparencyType(self)


    def setTransparentDelayedObjectRenderType(self, type):
        """setTransparentDelayedObjectRenderType(SoGLRenderAction self, SoGLRenderAction::TransparentDelayedObjectRenderType type)"""
        return _coin.SoGLRenderAction_setTransparentDelayedObjectRenderType(self, type)


    def getTransparentDelayedObjectRenderType(self):
        """getTransparentDelayedObjectRenderType(SoGLRenderAction self) -> SoGLRenderAction::TransparentDelayedObjectRenderType"""
        return _coin.SoGLRenderAction_getTransparentDelayedObjectRenderType(self)


    def setSmoothing(self, smooth):
        """setSmoothing(SoGLRenderAction self, SbBool const smooth)"""
        return _coin.SoGLRenderAction_setSmoothing(self, smooth)


    def isSmoothing(self):
        """isSmoothing(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isSmoothing(self)


    def setNumPasses(self, num):
        """setNumPasses(SoGLRenderAction self, int const num)"""
        return _coin.SoGLRenderAction_setNumPasses(self, num)


    def getNumPasses(self):
        """getNumPasses(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getNumPasses(self)


    def setPassUpdate(self, flag):
        """setPassUpdate(SoGLRenderAction self, SbBool const flag)"""
        return _coin.SoGLRenderAction_setPassUpdate(self, flag)


    def isPassUpdate(self):
        """isPassUpdate(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isPassUpdate(self)


    def setCacheContext(self, context):
        """setCacheContext(SoGLRenderAction self, uint32_t const context)"""
        return _coin.SoGLRenderAction_setCacheContext(self, context)


    def getCacheContext(self):
        """getCacheContext(SoGLRenderAction self) -> uint32_t"""
        return _coin.SoGLRenderAction_getCacheContext(self)


    def addDelayedPath(self, path):
        """addDelayedPath(SoGLRenderAction self, SoPath path)"""
        return _coin.SoGLRenderAction_addDelayedPath(self, path)


    def isRenderingDelayedPaths(self):
        """isRenderingDelayedPaths(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingDelayedPaths(self)


    def handleTransparency(self, istransparent=0):
        """
        handleTransparency(SoGLRenderAction self, SbBool istransparent=0) -> SbBool
        handleTransparency(SoGLRenderAction self) -> SbBool
        """
        return _coin.SoGLRenderAction_handleTransparency(self, istransparent)


    def setCurPass(self, passnum, numpasses):
        """setCurPass(SoGLRenderAction self, int const passnum, int const numpasses)"""
        return _coin.SoGLRenderAction_setCurPass(self, passnum, numpasses)


    def getCurPass(self):
        """getCurPass(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getCurPass(self)


    def abortNow(self):
        """abortNow(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_abortNow(self)


    def setRenderingIsRemote(self, isremote):
        """setRenderingIsRemote(SoGLRenderAction self, SbBool isremote)"""
        return _coin.SoGLRenderAction_setRenderingIsRemote(self, isremote)


    def getRenderingIsRemote(self):
        """getRenderingIsRemote(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_getRenderingIsRemote(self)


    def invalidateState(self):
        """invalidateState(SoGLRenderAction self)"""
        return _coin.SoGLRenderAction_invalidateState(self)


    def setSortedLayersNumPasses(self, num):
        """setSortedLayersNumPasses(SoGLRenderAction self, int num)"""
        return _coin.SoGLRenderAction_setSortedLayersNumPasses(self, num)


    def getSortedLayersNumPasses(self):
        """getSortedLayersNumPasses(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getSortedLayersNumPasses(self)


    def setSortedObjectOrderStrategy(self, strategy, cb=None, closure=None):
        """
        setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy, SoGLSortedObjectOrderCB * cb=None, void * closure=None)
        setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy, SoGLSortedObjectOrderCB * cb=None)
        setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy)
        """
        return _coin.SoGLRenderAction_setSortedObjectOrderStrategy(self, strategy, cb, closure)


    def setDelayedObjDepthWrite(self, write):
        """setDelayedObjDepthWrite(SoGLRenderAction self, SbBool write)"""
        return _coin.SoGLRenderAction_setDelayedObjDepthWrite(self, write)


    def getDelayedObjDepthWrite(self):
        """getDelayedObjDepthWrite(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_getDelayedObjDepthWrite(self)


    def isRenderingTranspPaths(self):
        """isRenderingTranspPaths(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingTranspPaths(self)


    def isRenderingTranspBackfaces(self):
        """isRenderingTranspBackfaces(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingTranspBackfaces(self)


    def setPassCallback(self, *args):
        """
        setPassCallback(SoGLRenderAction self, SoGLRenderPassCB *const func, void *const userdata)
        setPassCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_setPassCallback(self, *args)


    def setAbortCallback(self, *args):
        """
        setAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *const func, void *const userdata)
        setAbortCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_setAbortCallback(self, *args)


    def addPreRenderCallback(self, *args):
        """
        addPreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)
        addPreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_addPreRenderCallback(self, *args)


    def removePreRenderCallback(self, *args):
        """
        removePreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)
        removePreRenderCallback(SoGLRenderAction 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(type, method):
    """SoGLRenderAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoGLRenderAction_addMethod(type, method)

def SoGLRenderAction_enableElement(type, stackindex):
    """SoGLRenderAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoGLRenderAction_enableElement(type, stackindex)

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(SoBoxHighlightRenderAction self) -> SoType"""
        return _coin.SoBoxHighlightRenderAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoBoxHighlightRenderAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoBoxHighlightRenderAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoBoxHighlightRenderAction self) -> SoBoxHighlightRenderAction
        __init__(SoBoxHighlightRenderAction 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(SoBoxHighlightRenderAction self, SoNode node)
        apply(SoBoxHighlightRenderAction self, SoPath path)
        apply(SoBoxHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)
        apply(SoBoxHighlightRenderAction self, SoPathList pathlist)
        """
        return _coin.SoBoxHighlightRenderAction_apply(self, *args)


    def setVisible(self, visible):
        """setVisible(SoBoxHighlightRenderAction self, SbBool const visible)"""
        return _coin.SoBoxHighlightRenderAction_setVisible(self, visible)


    def isVisible(self):
        """isVisible(SoBoxHighlightRenderAction self) -> SbBool"""
        return _coin.SoBoxHighlightRenderAction_isVisible(self)


    def setColor(self, color):
        """setColor(SoBoxHighlightRenderAction self, SbColor color)"""
        return _coin.SoBoxHighlightRenderAction_setColor(self, color)


    def getColor(self):
        """getColor(SoBoxHighlightRenderAction self) -> SbColor"""
        return _coin.SoBoxHighlightRenderAction_getColor(self)


    def setLinePattern(self, pattern):
        """setLinePattern(SoBoxHighlightRenderAction self, unsigned short pattern)"""
        return _coin.SoBoxHighlightRenderAction_setLinePattern(self, pattern)


    def getLinePattern(self):
        """getLinePattern(SoBoxHighlightRenderAction self) -> unsigned short"""
        return _coin.SoBoxHighlightRenderAction_getLinePattern(self)


    def setLineWidth(self, width):
        """setLineWidth(SoBoxHighlightRenderAction self, float const width)"""
        return _coin.SoBoxHighlightRenderAction_setLineWidth(self, width)


    def getLineWidth(self):
        """getLineWidth(SoBoxHighlightRenderAction 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(type, method):
    """SoBoxHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoBoxHighlightRenderAction_addMethod(type, method)

def SoBoxHighlightRenderAction_enableElement(type, stackindex):
    """SoBoxHighlightRenderAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoBoxHighlightRenderAction_enableElement(type, stackindex)

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(SoLineHighlightRenderAction self) -> SoType"""
        return _coin.SoLineHighlightRenderAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoLineHighlightRenderAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoLineHighlightRenderAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoLineHighlightRenderAction self) -> SoLineHighlightRenderAction
        __init__(SoLineHighlightRenderAction 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(SoLineHighlightRenderAction self, SoNode node)
        apply(SoLineHighlightRenderAction self, SoPath path)
        apply(SoLineHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)
        apply(SoLineHighlightRenderAction self, SoPathList pathlist)
        """
        return _coin.SoLineHighlightRenderAction_apply(self, *args)


    def setVisible(self, visible):
        """setVisible(SoLineHighlightRenderAction self, SbBool const visible)"""
        return _coin.SoLineHighlightRenderAction_setVisible(self, visible)


    def isVisible(self):
        """isVisible(SoLineHighlightRenderAction self) -> SbBool"""
        return _coin.SoLineHighlightRenderAction_isVisible(self)


    def setColor(self, color):
        """setColor(SoLineHighlightRenderAction self, SbColor color)"""
        return _coin.SoLineHighlightRenderAction_setColor(self, color)


    def getColor(self):
        """getColor(SoLineHighlightRenderAction self) -> SbColor"""
        return _coin.SoLineHighlightRenderAction_getColor(self)


    def setLinePattern(self, pattern):
        """setLinePattern(SoLineHighlightRenderAction self, uint16_t pattern)"""
        return _coin.SoLineHighlightRenderAction_setLinePattern(self, pattern)


    def getLinePattern(self):
        """getLinePattern(SoLineHighlightRenderAction self) -> uint16_t"""
        return _coin.SoLineHighlightRenderAction_getLinePattern(self)


    def setLineWidth(self, width):
        """setLineWidth(SoLineHighlightRenderAction self, float const width)"""
        return _coin.SoLineHighlightRenderAction_setLineWidth(self, width)


    def getLineWidth(self):
        """getLineWidth(SoLineHighlightRenderAction 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(type, method):
    """SoLineHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoLineHighlightRenderAction_addMethod(type, method)

def SoLineHighlightRenderAction_enableElement(type, stackindex):
    """SoLineHighlightRenderAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoLineHighlightRenderAction_enableElement(type, stackindex)

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__(SbBox3f self) -> SbBox3f
        __init__(SbBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax) -> SbBox3f
        __init__(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f
        __init__(SbBox3f self, SbBox3d box) -> SbBox3f
        __init__(SbBox3f self, SbBox3s box) -> SbBox3f
        __init__(SbBox3f self, SbBox3i32 box) -> SbBox3f
        """
        this = _coin.new_SbBox3f(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setBounds(self, *args):
        """
        setBounds(SbBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax) -> SbBox3f
        setBounds(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f
        setBounds(SbBox3f self, SbBox3d box) -> SbBox3f
        setBounds(SbBox3f self, SbBox3s box) -> SbBox3f
        setBounds(SbBox3f self, SbBox3i32 box) -> SbBox3f
        """
        return _coin.SbBox3f_setBounds(self, *args)


    def getBounds(self, *args):
        """
        getBounds(SbBox3f self, float & xmin, float & ymin, float & zmin, float & xmax, float & ymax, float & zmax)
        getBounds(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint)
        """
        return _coin.SbBox3f_getBounds(self, *args)


    def getMin(self, *args):
        """
        getMin(SbBox3f self) -> SbVec3f
        getMin(SbBox3f self) -> SbVec3f
        """
        return _coin.SbBox3f_getMin(self, *args)


    def getMax(self, *args):
        """
        getMax(SbBox3f self) -> SbVec3f
        getMax(SbBox3f self) -> SbVec3f
        """
        return _coin.SbBox3f_getMax(self, *args)


    def extendBy(self, *args):
        """
        extendBy(SbBox3f self, SbVec3f pt)
        extendBy(SbBox3f self, SbBox3f box)
        """
        return _coin.SbBox3f_extendBy(self, *args)


    def transform(self, matrix):
        """transform(SbBox3f self, SbMatrix matrix)"""
        return _coin.SbBox3f_transform(self, matrix)


    def makeEmpty(self):
        """makeEmpty(SbBox3f self)"""
        return _coin.SbBox3f_makeEmpty(self)


    def isEmpty(self):
        """isEmpty(SbBox3f self) -> SbBool"""
        return _coin.SbBox3f_isEmpty(self)


    def hasVolume(self):
        """hasVolume(SbBox3f self) -> SbBool"""
        return _coin.SbBox3f_hasVolume(self)


    def getVolume(self):
        """getVolume(SbBox3f self) -> float"""
        return _coin.SbBox3f_getVolume(self)


    def intersect(self, *args):
        """
        intersect(SbBox3f self, SbVec3f pt) -> SbBool
        intersect(SbBox3f self, SbBox3f box) -> SbBool
        """
        return _coin.SbBox3f_intersect(self, *args)


    def getClosestPoint(self, point):
        """getClosestPoint(SbBox3f self, SbVec3f point) -> SbVec3f"""
        return _coin.SbBox3f_getClosestPoint(self, point)


    def outside(self, mvp, cullbits):
        """outside(SbBox3f self, SbMatrix mvp, int & cullbits) -> SbBool"""
        return _coin.SbBox3f_outside(self, mvp, cullbits)


    def getCenter(self):
        """getCenter(SbBox3f self) -> SbVec3f"""
        return _coin.SbBox3f_getCenter(self)


    def getOrigin(self, originX, originY, originZ):
        """getOrigin(SbBox3f self, float & originX, float & originY, float & originZ)"""
        return _coin.SbBox3f_getOrigin(self, originX, originY, originZ)


    def getSize(self, *args):
        """
        getSize(SbBox3f self, float & sizeX, float & sizeY, float & sizeZ)
        getSize(SbBox3f self) -> SbVec3f
        """
        return _coin.SbBox3f_getSize(self, *args)


    def getSpan(self, dir, dmin, dmax):
        """getSpan(SbBox3f self, SbVec3f dir, float & dmin, float & dmax)"""
        return _coin.SbBox3f_getSpan(self, dir, dmin, dmax)


    def output(self, file):
        """output(SbBox3f self, FILE * file)"""
        return _coin.SbBox3f_output(self, file)


    def __eq__(self, u):
        """__eq__(SbBox3f self, SbBox3f u) -> int"""
        return _coin.SbBox3f___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbBox3f self, SbBox3f u) -> int"""
        return _coin.SbBox3f___ne__(self, u)

    __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__(SbMatrix self) -> SbMatrix
        __init__(SbMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44) -> SbMatrix
        __init__(SbMatrix self, SbMat const & matrix) -> SbMatrix
        __init__(SbMatrix self, SbMat const * 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(SbMatrix self, SbMat const & m)
        setValue(SbMatrix self, SbDPMatrix m)
        """
        return _coin.SbMatrix_setValue(self, *args)


    def makeIdentity(self):
        """makeIdentity(SbMatrix self)"""
        return _coin.SbMatrix_makeIdentity(self)


    def setRotate(self, q):
        """setRotate(SbMatrix self, SbRotation q)"""
        return _coin.SbMatrix_setRotate(self, q)


    def inverse(self):
        """inverse(SbMatrix self) -> SbMatrix"""
        return _coin.SbMatrix_inverse(self)


    def det3(self, *args):
        """
        det3(SbMatrix self, int r1, int r2, int r3, int c1, int c2, int c3) -> float
        det3(SbMatrix self) -> float
        """
        return _coin.SbMatrix_det3(self, *args)


    def det4(self):
        """det4(SbMatrix self) -> float"""
        return _coin.SbMatrix_det4(self)


    def equals(self, m, tolerance):
        """equals(SbMatrix self, SbMatrix m, float tolerance) -> SbBool"""
        return _coin.SbMatrix_equals(self, m, tolerance)


    def __imul__(self, m):
        """__imul__(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix___imul__(self, m)


    def getValue(self, *args):
        """
        getValue(SbMatrix self) -> SbMat const
        getValue(SbMatrix 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(SbMatrix self, float const s)
        setScale(SbMatrix self, SbVec3f s)
        """
        return _coin.SbMatrix_setScale(self, *args)


    def setTranslate(self, t):
        """setTranslate(SbMatrix self, SbVec3f t)"""
        return _coin.SbMatrix_setTranslate(self, t)


    def setTransform(self, *args):
        """
        setTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s)
        setTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)
        setTransform(SbMatrix self, SbVec3f translation, SbRotation rotation, SbVec3f scaleFactor, SbRotation scaleOrientation, SbVec3f center)
        """
        return _coin.SbMatrix_setTransform(self, *args)


    def factor(self, r, s, u, t, proj):
        """factor(SbMatrix self, SbMatrix r, SbVec3f s, SbMatrix u, SbVec3f t, SbMatrix proj) -> SbBool"""
        return _coin.SbMatrix_factor(self, r, s, u, t, proj)


    def LUDecomposition(self, index, d):
        """LUDecomposition(SbMatrix self, int [4] index, float & d) -> SbBool"""
        return _coin.SbMatrix_LUDecomposition(self, index, d)


    def LUBackSubstitution(self, index, b):
        """LUBackSubstitution(SbMatrix self, int [4] index, float [4] b)"""
        return _coin.SbMatrix_LUBackSubstitution(self, index, b)


    def transpose(self):
        """transpose(SbMatrix self) -> SbMatrix"""
        return _coin.SbMatrix_transpose(self)


    def multRight(self, m):
        """multRight(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix_multRight(self, m)


    def multLeft(self, m):
        """multLeft(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix_multLeft(self, m)


    def multMatrixVec(self, src):
        """multMatrixVec(SbMatrix self, SbVec3f src)"""
        return _coin.SbMatrix_multMatrixVec(self, src)


    def multDirMatrix(self, src):
        """multDirMatrix(SbMatrix self, SbVec3f src)"""
        return _coin.SbMatrix_multDirMatrix(self, src)


    def multLineMatrix(self, src, dst):
        """multLineMatrix(SbMatrix self, SbLine src, SbLine dst)"""
        return _coin.SbMatrix_multLineMatrix(self, src, dst)


    def multVecMatrix(self, *args):
        """
        multVecMatrix(SbMatrix self, SbVec3f src)
        multVecMatrix(SbMatrix self, SbVec4f src)
        """
        return _coin.SbMatrix_multVecMatrix(self, *args)


    def output(self, fp):
        """output(SbMatrix self, FILE * fp)"""
        return _coin.SbMatrix_output(self, fp)


    def getTransform(self, *args):
        """
        getTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)
        getTransform(SbMatrix self) -> PyObject
        getTransform(SbMatrix self, SbVec3f center) -> PyObject *
        """
        return _coin.SbMatrix_getTransform(self, *args)


    def __mul__(self, *args):
        """
        __mul__(SbMatrix self, SbMatrix u) -> SbMatrix
        __mul__(SbMatrix self, SbVec3f u) -> SbVec3f
        """
        return _coin.SbMatrix___mul__(self, *args)


    def __rmul__(self, u):
        """__rmul__(SbMatrix self, SbVec3f u) -> SbVec3f"""
        return _coin.SbMatrix___rmul__(self, u)


    def __eq__(self, u):
        """__eq__(SbMatrix self, SbMatrix u) -> int"""
        return _coin.SbMatrix___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbMatrix self, SbMatrix u) -> int"""
        return _coin.SbMatrix___ne__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbMatrix self, int i) -> float const *"""
        return _coin.SbMatrix___getitem__(self, i)

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__(SbXfBox3f self) -> SbXfBox3f
        __init__(SbXfBox3f self, SbVec3f boxmin, SbVec3f boxmax) -> SbXfBox3f
        __init__(SbXfBox3f 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, m):
        """setTransform(SbXfBox3f self, SbMatrix m)"""
        return _coin.SbXfBox3f_setTransform(self, m)


    def getTransform(self):
        """getTransform(SbXfBox3f self) -> SbMatrix"""
        return _coin.SbXfBox3f_getTransform(self)


    def getInverse(self):
        """getInverse(SbXfBox3f self) -> SbMatrix"""
        return _coin.SbXfBox3f_getInverse(self)


    def getCenter(self):
        """getCenter(SbXfBox3f self) -> SbVec3f"""
        return _coin.SbXfBox3f_getCenter(self)


    def extendBy(self, *args):
        """
        extendBy(SbXfBox3f self, SbVec3f pt)
        extendBy(SbXfBox3f self, SbBox3f bb)
        extendBy(SbXfBox3f self, SbXfBox3f bb)
        """
        return _coin.SbXfBox3f_extendBy(self, *args)


    def intersect(self, *args):
        """
        intersect(SbXfBox3f self, SbVec3f pt) -> SbBool
        intersect(SbXfBox3f self, SbBox3f bb) -> SbBool
        intersect(SbXfBox3f self, SbXfBox3f bb) -> SbBool
        """
        return _coin.SbXfBox3f_intersect(self, *args)


    def getSpan(self, direction, dMin, dMax):
        """getSpan(SbXfBox3f self, SbVec3f direction, float & dMin, float & dMax)"""
        return _coin.SbXfBox3f_getSpan(self, direction, dMin, dMax)


    def project(self):
        """project(SbXfBox3f self) -> SbBox3f"""
        return _coin.SbXfBox3f_project(self)


    def transform(self, m):
        """transform(SbXfBox3f self, SbMatrix m)"""
        return _coin.SbXfBox3f_transform(self, m)


    def getVolume(self):
        """getVolume(SbXfBox3f self) -> float"""
        return _coin.SbXfBox3f_getVolume(self)


    def output(self, file):
        """output(SbXfBox3f self, FILE * file)"""
        return _coin.SbXfBox3f_output(self, file)


    def __eq__(self, u):
        """__eq__(SbXfBox3f self, SbXfBox3f u) -> int"""
        return _coin.SbXfBox3f___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbXfBox3f self, SbXfBox3f u) -> int"""
        return _coin.SbXfBox3f___ne__(self, u)

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(SoGetBoundingBoxAction self) -> SoType"""
        return _coin.SoGetBoundingBoxAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetBoundingBoxAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetBoundingBoxAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self, vp):
        """__init__(SoGetBoundingBoxAction self, SbViewportRegion vp) -> SoGetBoundingBoxAction"""
        this = _coin.new_SoGetBoundingBoxAction(vp)
        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, newregion):
        """setViewportRegion(SoGetBoundingBoxAction self, SbViewportRegion newregion)"""
        return _coin.SoGetBoundingBoxAction_setViewportRegion(self, newregion)


    def getViewportRegion(self):
        """getViewportRegion(SoGetBoundingBoxAction self) -> SbViewportRegion"""
        return _coin.SoGetBoundingBoxAction_getViewportRegion(self)


    def getBoundingBox(self):
        """getBoundingBox(SoGetBoundingBoxAction self) -> SbBox3f"""
        return _coin.SoGetBoundingBoxAction_getBoundingBox(self)


    def getXfBoundingBox(self):
        """getXfBoundingBox(SoGetBoundingBoxAction self) -> SbXfBox3f"""
        return _coin.SoGetBoundingBoxAction_getXfBoundingBox(self)


    def getCenter(self):
        """getCenter(SoGetBoundingBoxAction self) -> SbVec3f"""
        return _coin.SoGetBoundingBoxAction_getCenter(self)


    def setInCameraSpace(self, flag):
        """setInCameraSpace(SoGetBoundingBoxAction self, SbBool const flag)"""
        return _coin.SoGetBoundingBoxAction_setInCameraSpace(self, flag)


    def isInCameraSpace(self):
        """isInCameraSpace(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isInCameraSpace(self)


    def setResetPath(self, *args):
        """
        setResetPath(SoGetBoundingBoxAction self, SoPath path, SbBool const resetbefore=1, SoGetBoundingBoxAction::ResetType const what)
        setResetPath(SoGetBoundingBoxAction self, SoPath path, SbBool const resetbefore=1)
        setResetPath(SoGetBoundingBoxAction self, SoPath path)
        """
        return _coin.SoGetBoundingBoxAction_setResetPath(self, *args)


    def getResetPath(self):
        """getResetPath(SoGetBoundingBoxAction self) -> SoPath"""
        return _coin.SoGetBoundingBoxAction_getResetPath(self)


    def isResetPath(self):
        """isResetPath(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isResetPath(self)


    def isResetBefore(self):
        """isResetBefore(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isResetBefore(self)


    def getWhatReset(self):
        """getWhatReset(SoGetBoundingBoxAction self) -> SoGetBoundingBoxAction::ResetType"""
        return _coin.SoGetBoundingBoxAction_getWhatReset(self)


    def checkResetBefore(self):
        """checkResetBefore(SoGetBoundingBoxAction self)"""
        return _coin.SoGetBoundingBoxAction_checkResetBefore(self)


    def checkResetAfter(self):
        """checkResetAfter(SoGetBoundingBoxAction self)"""
        return _coin.SoGetBoundingBoxAction_checkResetAfter(self)


    def extendBy(self, *args):
        """
        extendBy(SoGetBoundingBoxAction self, SbBox3f box)
        extendBy(SoGetBoundingBoxAction self, SbXfBox3f box)
        """
        return _coin.SoGetBoundingBoxAction_extendBy(self, *args)


    def setCenter(self, center, transformcenter):
        """setCenter(SoGetBoundingBoxAction self, SbVec3f center, SbBool const transformcenter)"""
        return _coin.SoGetBoundingBoxAction_setCenter(self, center, transformcenter)


    def isCenterSet(self):
        """isCenterSet(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isCenterSet(self)


    def resetCenter(self):
        """resetCenter(SoGetBoundingBoxAction 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(type, method):
    """SoGetBoundingBoxAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoGetBoundingBoxAction_addMethod(type, method)

def SoGetBoundingBoxAction_enableElement(type, stackindex):
    """SoGetBoundingBoxAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoGetBoundingBoxAction_enableElement(type, stackindex)

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__(SbVec4f self) -> SbVec4f
        __init__(SbVec4f self, float const [4] v) -> SbVec4f
        __init__(SbVec4f self, float x, float y, float z, float w) -> SbVec4f
        __init__(SbVec4f self, SbVec4d v) -> SbVec4f
        __init__(SbVec4f self, SbVec4b v) -> SbVec4f
        __init__(SbVec4f self, SbVec4s v) -> SbVec4f
        __init__(SbVec4f self, SbVec4i32 v) -> SbVec4f
        """
        this = _coin.new_SbVec4f(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec4f self, float const [4] v) -> SbVec4f
        setValue(SbVec4f self, float x, float y, float z, float w) -> SbVec4f
        setValue(SbVec4f self, SbVec4d v) -> SbVec4f
        setValue(SbVec4f self, SbVec4b v) -> SbVec4f
        setValue(SbVec4f self, SbVec4s v) -> SbVec4f
        setValue(SbVec4f self, SbVec4i32 v) -> SbVec4f
        """
        return _coin.SbVec4f_setValue(self, *args)


    def getValue(self):
        """getValue(SbVec4f self) -> float const *"""
        return _coin.SbVec4f_getValue(self)


    def equals(self, v, tolerance):
        """equals(SbVec4f self, SbVec4f v, float tolerance) -> SbBool"""
        return _coin.SbVec4f_equals(self, v, tolerance)


    def dot(self, v):
        """dot(SbVec4f self, SbVec4f v) -> float"""
        return _coin.SbVec4f_dot(self, v)


    def getReal(self, v):
        """getReal(SbVec4f self, SbVec3f v)"""
        return _coin.SbVec4f_getReal(self, v)


    def length(self):
        """length(SbVec4f self) -> float"""
        return _coin.SbVec4f_length(self)


    def sqrLength(self):
        """sqrLength(SbVec4f self) -> float"""
        return _coin.SbVec4f_sqrLength(self)


    def negate(self):
        """negate(SbVec4f self)"""
        return _coin.SbVec4f_negate(self)


    def normalize(self):
        """normalize(SbVec4f self) -> float"""
        return _coin.SbVec4f_normalize(self)


    def __imul__(self, d):
        """__imul__(SbVec4f self, float d) -> SbVec4f"""
        return _coin.SbVec4f___imul__(self, d)


    def __idiv__(self, d):
        """__idiv__(SbVec4f self, float d) -> SbVec4f"""
        return _coin.SbVec4f___idiv__(self, d)


    def __iadd__(self, v):
        """__iadd__(SbVec4f self, SbVec4f v) -> SbVec4f"""
        return _coin.SbVec4f___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec4f self, SbVec4f v) -> SbVec4f"""
        return _coin.SbVec4f___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec4f self) -> SbVec4f"""
        return _coin.SbVec4f___neg__(self)


    def output(self, fp):
        """output(SbVec4f self, FILE * fp)"""
        return _coin.SbVec4f_output(self, fp)


    def __add__(self, u):
        """__add__(SbVec4f self, SbVec4f u) -> SbVec4f"""
        return _coin.SbVec4f___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbVec4f self, SbVec4f u) -> SbVec4f"""
        return _coin.SbVec4f___sub__(self, u)


    def __mul__(self, *args):
        """
        __mul__(SbVec4f self, float const d) -> SbVec4f
        __mul__(SbVec4f self, SbMatrix m) -> SbVec4f
        """
        return _coin.SbVec4f___mul__(self, *args)


    def __rmul__(self, d):
        """__rmul__(SbVec4f self, float const d) -> SbVec4f"""
        return _coin.SbVec4f___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbVec4f self, float const d) -> SbVec4f"""
        return _coin.SbVec4f___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbVec4f self, SbVec4f u) -> int"""
        return _coin.SbVec4f___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbVec4f self, SbVec4f u) -> int"""
        return _coin.SbVec4f___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbVec4f self, int i) -> float"""
        return _coin.SbVec4f___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SbVec4f self, int i, float value)"""
        return _coin.SbVec4f___setitem__(self, i, value)


    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__(SbRotation self) -> SbRotation
        __init__(SbRotation self, SbVec3f axis, float const radians) -> SbRotation
        __init__(SbRotation self, float const [4] q) -> SbRotation
        __init__(SbRotation self, float const q0, float const q1, float const q2, float const q3) -> SbRotation
        __init__(SbRotation self, SbMatrix m) -> SbRotation
        __init__(SbRotation self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation
        """
        this = _coin.new_SbRotation(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getValue(self):
        """getValue(SbRotation self) -> float const *"""
        return _coin.SbRotation_getValue(self)


    def getAxisAngle(self):
        """getAxisAngle(SbRotation self)"""
        return _coin.SbRotation_getAxisAngle(self)


    def getMatrix(self):
        """getMatrix(SbRotation self)"""
        return _coin.SbRotation_getMatrix(self)


    def invert(self):
        """invert(SbRotation self) -> SbRotation"""
        return _coin.SbRotation_invert(self)


    def inverse(self):
        """inverse(SbRotation self) -> SbRotation"""
        return _coin.SbRotation_inverse(self)


    def setValue(self, *args):
        """
        setValue(SbRotation self, float const q0, float const q1, float const q2, float const q3) -> SbRotation
        setValue(SbRotation self, float const [4] q) -> SbRotation
        setValue(SbRotation self, SbMatrix m) -> SbRotation
        setValue(SbRotation self, SbVec3f axis, float const radians) -> SbRotation
        setValue(SbRotation self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation
        """
        return _coin.SbRotation_setValue(self, *args)


    def __imul__(self, *args):
        """
        __imul__(SbRotation self, SbRotation q) -> SbRotation
        __imul__(SbRotation self, float const s) -> SbRotation
        """
        return _coin.SbRotation___imul__(self, *args)


    def equals(self, r, tolerance):
        """equals(SbRotation self, SbRotation r, float const tolerance) -> SbBool"""
        return _coin.SbRotation_equals(self, r, tolerance)


    def multVec(self, src):
        """multVec(SbRotation self, SbVec3f src)"""
        return _coin.SbRotation_multVec(self, src)


    def scaleAngle(self, scaleFactor):
        """scaleAngle(SbRotation self, float const scaleFactor)"""
        return _coin.SbRotation_scaleAngle(self, scaleFactor)


    def slerp(rot0, rot1, t):
        """slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
        return _coin.SbRotation_slerp(rot0, rot1, t)

    slerp = staticmethod(slerp)

    def identity():
        """identity() -> SbRotation"""
        return _coin.SbRotation_identity()

    identity = staticmethod(identity)

    def output(self, fp):
        """output(SbRotation self, FILE * fp)"""
        return _coin.SbRotation_output(self, fp)


    def __mul__(self, *args):
        """
        __mul__(SbRotation self, SbRotation u) -> SbRotation
        __mul__(SbRotation self, double const d) -> SbRotation
        __mul__(SbRotation self, SbVec3f v) -> SbVec3f
        """
        return _coin.SbRotation___mul__(self, *args)


    def __eq__(self, u):
        """__eq__(SbRotation self, SbRotation u) -> int"""
        return _coin.SbRotation___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbRotation self, SbRotation u) -> int"""
        return _coin.SbRotation___nq__(self, u)

    __swig_destroy__ = _coin.delete_SbRotation
    __del__ = lambda self: None
SbRotation_swigregister = _coin.SbRotation_swigregister
SbRotation_swigregister(SbRotation)

def SbRotation_slerp(rot0, rot1, t):
    """SbRotation_slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
    return _coin.SbRotation_slerp(rot0, rot1, t)

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(SoGetMatrixAction self) -> SoType"""
        return _coin.SoGetMatrixAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetMatrixAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetMatrixAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self, region):
        """__init__(SoGetMatrixAction self, SbViewportRegion region) -> SoGetMatrixAction"""
        this = _coin.new_SoGetMatrixAction(region)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoGetMatrixAction
    __del__ = lambda self: None

    def setViewportRegion(self, region):
        """setViewportRegion(SoGetMatrixAction self, SbViewportRegion region)"""
        return _coin.SoGetMatrixAction_setViewportRegion(self, region)


    def getViewportRegion(self):
        """getViewportRegion(SoGetMatrixAction self) -> SbViewportRegion"""
        return _coin.SoGetMatrixAction_getViewportRegion(self)


    def getMatrix(self):
        """getMatrix(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getMatrix(self)


    def getInverse(self):
        """getInverse(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getInverse(self)


    def getTextureMatrix(self):
        """getTextureMatrix(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getTextureMatrix(self)


    def getTextureInverse(self):
        """getTextureInverse(SoGetMatrixAction 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(type, method):
    """SoGetMatrixAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoGetMatrixAction_addMethod(type, method)

def SoGetMatrixAction_enableElement(type, stackindex):
    """SoGetMatrixAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoGetMatrixAction_enableElement(type, stackindex)

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(SoGetPrimitiveCountAction self) -> SoType"""
        return _coin.SoGetPrimitiveCountAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetPrimitiveCountAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetPrimitiveCountAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoGetPrimitiveCountAction 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(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getTriangleCount(self)


    def getLineCount(self):
        """getLineCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getLineCount(self)


    def getPointCount(self):
        """getPointCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getPointCount(self)


    def getTextCount(self):
        """getTextCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getTextCount(self)


    def getImageCount(self):
        """getImageCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getImageCount(self)


    def containsNoPrimitives(self):
        """containsNoPrimitives(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_containsNoPrimitives(self)


    def containsNonTriangleShapes(self):
        """containsNonTriangleShapes(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_containsNonTriangleShapes(self)


    def is3DTextCountedAsTriangles(self):
        """is3DTextCountedAsTriangles(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_is3DTextCountedAsTriangles(self)


    def setCount3DTextAsTriangles(self, flag):
        """setCount3DTextAsTriangles(SoGetPrimitiveCountAction self, SbBool const flag)"""
        return _coin.SoGetPrimitiveCountAction_setCount3DTextAsTriangles(self, flag)


    def canApproximateCount(self):
        """canApproximateCount(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_canApproximateCount(self)


    def setCanApproximate(self, flag):
        """setCanApproximate(SoGetPrimitiveCountAction self, SbBool const flag)"""
        return _coin.SoGetPrimitiveCountAction_setCanApproximate(self, flag)


    def setDecimationValue(self, type, percentage=1.0):
        """
        setDecimationValue(SoGetPrimitiveCountAction self, SoDecimationTypeElement::Type type, float percentage=1.0)
        setDecimationValue(SoGetPrimitiveCountAction self, SoDecimationTypeElement::Type type)
        """
        return _coin.SoGetPrimitiveCountAction_setDecimationValue(self, type, percentage)


    def getDecimationType(self):
        """getDecimationType(SoGetPrimitiveCountAction self) -> SoDecimationTypeElement::Type"""
        return _coin.SoGetPrimitiveCountAction_getDecimationType(self)


    def getDecimationPercentage(self):
        """getDecimationPercentage(SoGetPrimitiveCountAction self) -> float"""
        return _coin.SoGetPrimitiveCountAction_getDecimationPercentage(self)


    def addNumTriangles(self, num):
        """addNumTriangles(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumTriangles(self, num)


    def addNumLines(self, num):
        """addNumLines(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumLines(self, num)


    def addNumPoints(self, num):
        """addNumPoints(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumPoints(self, num)


    def addNumText(self, num):
        """addNumText(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumText(self, num)


    def addNumImage(self, num):
        """addNumImage(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumImage(self, num)


    def incNumTriangles(self):
        """incNumTriangles(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumTriangles(self)


    def incNumLines(self):
        """incNumLines(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumLines(self)


    def incNumPoints(self):
        """incNumPoints(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumPoints(self)


    def incNumText(self):
        """incNumText(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumText(self)


    def incNumImage(self):
        """incNumImage(SoGetPrimitiveCountAction 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(type, method):
    """SoGetPrimitiveCountAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoGetPrimitiveCountAction_addMethod(type, method)

def SoGetPrimitiveCountAction_enableElement(type, stackindex):
    """SoGetPrimitiveCountAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoGetPrimitiveCountAction_enableElement(type, stackindex)

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(SoHandleEventAction self) -> SoType"""
        return _coin.SoHandleEventAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoHandleEventAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoHandleEventAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self, viewportregion):
        """__init__(SoHandleEventAction self, SbViewportRegion viewportregion) -> SoHandleEventAction"""
        this = _coin.new_SoHandleEventAction(viewportregion)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoHandleEventAction
    __del__ = lambda self: None

    def setViewportRegion(self, newregion):
        """setViewportRegion(SoHandleEventAction self, SbViewportRegion newregion)"""
        return _coin.SoHandleEventAction_setViewportRegion(self, newregion)


    def getViewportRegion(self):
        """getViewportRegion(SoHandleEventAction self) -> SbViewportRegion"""
        return _coin.SoHandleEventAction_getViewportRegion(self)


    def setEvent(self, ev):
        """setEvent(SoHandleEventAction self, SoEvent ev)"""
        return _coin.SoHandleEventAction_setEvent(self, ev)


    def getEvent(self):
        """getEvent(SoHandleEventAction self) -> SoEvent"""
        return _coin.SoHandleEventAction_getEvent(self)


    def setHandled(self):
        """setHandled(SoHandleEventAction self)"""
        return _coin.SoHandleEventAction_setHandled(self)


    def isHandled(self):
        """isHandled(SoHandleEventAction self) -> SbBool"""
        return _coin.SoHandleEventAction_isHandled(self)


    def setGrabber(self, node):
        """setGrabber(SoHandleEventAction self, SoNode node)"""
        return _coin.SoHandleEventAction_setGrabber(self, node)


    def releaseGrabber(self):
        """releaseGrabber(SoHandleEventAction self)"""
        return _coin.SoHandleEventAction_releaseGrabber(self)


    def getGrabber(self):
        """getGrabber(SoHandleEventAction self) -> SoNode"""
        return _coin.SoHandleEventAction_getGrabber(self)


    def setPickRoot(self, node):
        """setPickRoot(SoHandleEventAction self, SoNode node)"""
        return _coin.SoHandleEventAction_setPickRoot(self, node)


    def getPickRoot(self):
        """getPickRoot(SoHandleEventAction self) -> SoNode"""
        return _coin.SoHandleEventAction_getPickRoot(self)


    def setPickRadius(self, radiusinpixels):
        """setPickRadius(SoHandleEventAction self, float const radiusinpixels)"""
        return _coin.SoHandleEventAction_setPickRadius(self, radiusinpixels)


    def getPickedPoint(self):
        """getPickedPoint(SoHandleEventAction self) -> SoPickedPoint"""
        return _coin.SoHandleEventAction_getPickedPoint(self)


    def getPickedPointList(self):
        """getPickedPointList(SoHandleEventAction 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(type, method):
    """SoHandleEventAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoHandleEventAction_addMethod(type, method)

def SoHandleEventAction_enableElement(type, stackindex):
    """SoHandleEventAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoHandleEventAction_enableElement(type, stackindex)

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(SoPickAction self) -> SoType"""
        return _coin.SoPickAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoPickAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoPickAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def setViewportRegion(self, newregion):
        """setViewportRegion(SoPickAction self, SbViewportRegion newregion)"""
        return _coin.SoPickAction_setViewportRegion(self, newregion)


    def getViewportRegion(self):
        """getViewportRegion(SoPickAction self) -> SbViewportRegion"""
        return _coin.SoPickAction_getViewportRegion(self)


    def enableCulling(self, flag):
        """enableCulling(SoPickAction self, SbBool const flag)"""
        return _coin.SoPickAction_enableCulling(self, flag)


    def isCullingEnabled(self):
        """isCullingEnabled(SoPickAction 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(type, method):
    """SoPickAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoPickAction_addMethod(type, method)

def SoPickAction_enableElement(type, stackindex):
    """SoPickAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoPickAction_enableElement(type, stackindex)

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(SoRayPickAction self) -> SoType"""
        return _coin.SoRayPickAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoRayPickAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoRayPickAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

    def __init__(self, viewportregion):
        """__init__(SoRayPickAction self, SbViewportRegion viewportregion) -> SoRayPickAction"""
        this = _coin.new_SoRayPickAction(viewportregion)
        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, viewportPoint):
        """setPoint(SoRayPickAction self, SbVec2s viewportPoint)"""
        return _coin.SoRayPickAction_setPoint(self, viewportPoint)


    def setNormalizedPoint(self, normpoint):
        """setNormalizedPoint(SoRayPickAction self, SbVec2f normpoint)"""
        return _coin.SoRayPickAction_setNormalizedPoint(self, normpoint)


    def setRadius(self, radiusinpixels):
        """setRadius(SoRayPickAction self, float const radiusinpixels)"""
        return _coin.SoRayPickAction_setRadius(self, radiusinpixels)


    def setRay(self, start, direction, neardistance=-1.0, fardistance=-1.0):
        """
        setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction, float neardistance=-1.0, float fardistance=-1.0)
        setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction, float neardistance=-1.0)
        setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction)
        """
        return _coin.SoRayPickAction_setRay(self, start, direction, neardistance, fardistance)


    def setPickAll(self, flag):
        """setPickAll(SoRayPickAction self, SbBool const flag)"""
        return _coin.SoRayPickAction_setPickAll(self, flag)


    def isPickAll(self):
        """isPickAll(SoRayPickAction self) -> SbBool"""
        return _coin.SoRayPickAction_isPickAll(self)


    def getPickedPointList(self):
        """getPickedPointList(SoRayPickAction self) -> SoPickedPointList"""
        return _coin.SoRayPickAction_getPickedPointList(self)


    def getPickedPoint(self, index=0):
        """
        getPickedPoint(SoRayPickAction self, int const index=0) -> SoPickedPoint
        getPickedPoint(SoRayPickAction self) -> SoPickedPoint
        """
        return _coin.SoRayPickAction_getPickedPoint(self, index)


    def computeWorldSpaceRay(self):
        """computeWorldSpaceRay(SoRayPickAction self)"""
        return _coin.SoRayPickAction_computeWorldSpaceRay(self)


    def hasWorldSpaceRay(self):
        """hasWorldSpaceRay(SoRayPickAction self) -> SbBool"""
        return _coin.SoRayPickAction_hasWorldSpaceRay(self)


    def setObjectSpace(self, *args):
        """
        setObjectSpace(SoRayPickAction self)
        setObjectSpace(SoRayPickAction self)
        """
        return _coin.SoRayPickAction_setObjectSpace(self, *args)


    def intersect(self, *args):
        """
        intersect(SoRayPickAction self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f intersection, SbVec3f barycentric, SbBool & front) -> SbBool
        intersect(SoRayPickAction self, SbVec3f v0, SbVec3f v1, SbVec3f intersection) -> SbBool
        intersect(SoRayPickAction self, SbVec3f point) -> SbBool
        intersect(SoRayPickAction self, SbBox3f box, SbBool const usefullviewvolume=1) -> SbBool
        intersect(SoRayPickAction self, SbBox3f box) -> SbBool
        intersect(SoRayPickAction self, SbBox3f box, SbVec3f intersection, SbBool const usefullviewvolume=1) -> SbBool
        intersect(SoRayPickAction self, SbBox3f box, SbVec3f intersection) -> SbBool
        """
        return _coin.SoRayPickAction_intersect(self, *args)


    def getViewVolume(self):
        """getViewVolume(SoRayPickAction self) -> SbViewVolume"""
        return _coin.SoRayPickAction_getViewVolume(self)


    def getLine(self):
        """getLine(SoRayPickAction self) -> SbLine"""
        return _coin.SoRayPickAction_getLine(self)


    def isBetweenPlanes(self, intersection):
        """isBetweenPlanes(SoRayPickAction self, SbVec3f intersection) -> SbBool"""
        return _coin.SoRayPickAction_isBetweenPlanes(self, intersection)


    def addIntersection(self, objectspacepoint, frontpick=1):
        """
        addIntersection(SoRayPickAction self, SbVec3f objectspacepoint, SbBool frontpick=1) -> SoPickedPoint
        addIntersection(SoRayPickAction self, SbVec3f objectspacepoint) -> SoPickedPoint
        """
        return _coin.SoRayPickAction_addIntersection(self, objectspacepoint, frontpick)


    def reset(self):
        """reset(SoRayPickAction 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(type, method):
    """SoRayPickAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoRayPickAction_addMethod(type, method)

def SoRayPickAction_enableElement(type, stackindex):
    """SoRayPickAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoRayPickAction_enableElement(type, stackindex)

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(SoSearchAction self) -> SoType"""
        return _coin.SoSearchAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoSearchAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoSearchAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSearchAction 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, node):
        """setNode(SoSearchAction self, SoNode node)"""
        return _coin.SoSearchAction_setNode(self, node)


    def getNode(self):
        """getNode(SoSearchAction self) -> SoNode"""
        return _coin.SoSearchAction_getNode(self)


    def setType(self, type, chkderived=1):
        """
        setType(SoSearchAction self, SoType type, SbBool const chkderived=1)
        setType(SoSearchAction self, SoType type)
        """
        return _coin.SoSearchAction_setType(self, type, chkderived)


    def getType(self, chkderived):
        """getType(SoSearchAction self, SbBool & chkderived) -> SoType"""
        return _coin.SoSearchAction_getType(self, chkderived)


    def setName(self, name):
        """setName(SoSearchAction self, SbName name)"""
        return _coin.SoSearchAction_setName(self, name)


    def getName(self):
        """getName(SoSearchAction self) -> SbName"""
        return _coin.SoSearchAction_getName(self)


    def setFind(self, what):
        """setFind(SoSearchAction self, int const what)"""
        return _coin.SoSearchAction_setFind(self, what)


    def getFind(self):
        """getFind(SoSearchAction self) -> int"""
        return _coin.SoSearchAction_getFind(self)


    def setInterest(self, interest):
        """setInterest(SoSearchAction self, SoSearchAction::Interest const interest)"""
        return _coin.SoSearchAction_setInterest(self, interest)


    def getInterest(self):
        """getInterest(SoSearchAction self) -> SoSearchAction::Interest"""
        return _coin.SoSearchAction_getInterest(self)


    def setSearchingAll(self, searchall):
        """setSearchingAll(SoSearchAction self, SbBool const searchall)"""
        return _coin.SoSearchAction_setSearchingAll(self, searchall)


    def isSearchingAll(self):
        """isSearchingAll(SoSearchAction self) -> SbBool"""
        return _coin.SoSearchAction_isSearchingAll(self)


    def getPath(self):
        """getPath(SoSearchAction self) -> SoPath"""
        return _coin.SoSearchAction_getPath(self)


    def getPaths(self):
        """getPaths(SoSearchAction self) -> SoPathList"""
        return _coin.SoSearchAction_getPaths(self)


    def reset(self):
        """reset(SoSearchAction self)"""
        return _coin.SoSearchAction_reset(self)


    def setFound(self):
        """setFound(SoSearchAction self)"""
        return _coin.SoSearchAction_setFound(self)


    def isFound(self):
        """isFound(SoSearchAction self) -> SbBool"""
        return _coin.SoSearchAction_isFound(self)


    def addPath(self, path):
        """addPath(SoSearchAction self, SoPath path)"""
        return _coin.SoSearchAction_addPath(self, path)

    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(type, method):
    """SoSearchAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoSearchAction_addMethod(type, method)

def SoSearchAction_enableElement(type, stackindex):
    """SoSearchAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoSearchAction_enableElement(type, stackindex)

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(SoSimplifyAction self) -> SoType"""
        return _coin.SoSimplifyAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoSimplifyAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoSimplifyAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSimplifyAction 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(SoSimplifyAction self, SoNode root)
        apply(SoSimplifyAction self, SoPath path)
        apply(SoSimplifyAction self, SoPathList pathlist, SbBool obeysrules=0)
        apply(SoSimplifyAction 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(type, method):
    """SoSimplifyAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoSimplifyAction_addMethod(type, method)

def SoSimplifyAction_enableElement(type, stackindex):
    """SoSimplifyAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoSimplifyAction_enableElement(type, stackindex)

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(SoReorganizeAction self) -> SoType"""
        return _coin.SoReorganizeAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoReorganizeAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoReorganizeAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self, simplifier=None):
        """
        __init__(SoReorganizeAction self, SoSimplifier * simplifier=None) -> SoReorganizeAction
        __init__(SoReorganizeAction 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(SoReorganizeAction self) -> SoSeparator"""
        return _coin.SoReorganizeAction_getSimplifiedSceneGraph(self)


    def generateNormals(self, onoff):
        """generateNormals(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateNormals(self, onoff)


    def areNormalGenerated(self):
        """areNormalGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areNormalGenerated(self)


    def generateTriangleStrips(self, onoff):
        """generateTriangleStrips(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateTriangleStrips(self, onoff)


    def areTriangleStripGenerated(self):
        """areTriangleStripGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areTriangleStripGenerated(self)


    def generateTexCoords(self, onoff):
        """generateTexCoords(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateTexCoords(self, onoff)


    def areTexCoordsGenerated(self):
        """areTexCoordsGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areTexCoordsGenerated(self)


    def generateVPNodes(self, onoff):
        """generateVPNodes(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateVPNodes(self, onoff)


    def areVPNodesGenerated(self):
        """areVPNodesGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areVPNodesGenerated(self)


    def matchIndexArrays(self, onoff):
        """matchIndexArrays(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_matchIndexArrays(self, onoff)


    def areIndexArraysMatched(self):
        """areIndexArraysMatched(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areIndexArraysMatched(self)


    def getSimplifier(self):
        """getSimplifier(SoReorganizeAction self) -> SoSimplifier *"""
        return _coin.SoReorganizeAction_getSimplifier(self)


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


    def startReport(msg):
        """startReport(char const * msg)"""
        return _coin.SoReorganizeAction_startReport(msg)

    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(type, method):
    """SoReorganizeAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoReorganizeAction_addMethod(type, method)

def SoReorganizeAction_enableElement(type, stackindex):
    """SoReorganizeAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoReorganizeAction_enableElement(type, stackindex)

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

def SoReorganizeAction_startReport(msg):
    """SoReorganizeAction_startReport(char const * msg)"""
    return _coin.SoReorganizeAction_startReport(msg)

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(SoWriteAction self) -> SoType"""
        return _coin.SoWriteAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoWriteAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoWriteAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

    def __init__(self, *args):
        """
        __init__(SoWriteAction self) -> SoWriteAction
        __init__(SoWriteAction 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(SoWriteAction self) -> SoOutput"""
        return _coin.SoWriteAction_getOutput(self)


    def continueToApply(self, *args):
        """
        continueToApply(SoWriteAction self, SoNode node)
        continueToApply(SoWriteAction 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(type, method):
    """SoWriteAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoWriteAction_addMethod(type, method)

def SoWriteAction_enableElement(type, stackindex):
    """SoWriteAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoWriteAction_enableElement(type, stackindex)

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(SoAudioRenderAction self) -> SoType"""
        return _coin.SoAudioRenderAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoAudioRenderAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoAudioRenderAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoAudioRenderAction 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(action, node):
        """callDoAction(SoAction action, SoNode node)"""
        return _coin.SoAudioRenderAction_callDoAction(action, node)

    callDoAction = staticmethod(callDoAction)

    def callAudioRender(action, node):
        """callAudioRender(SoAction action, SoNode node)"""
        return _coin.SoAudioRenderAction_callAudioRender(action, node)

    callAudioRender = staticmethod(callAudioRender)
SoAudioRenderAction_swigregister = _coin.SoAudioRenderAction_swigregister
SoAudioRenderAction_swigregister(SoAudioRenderAction)

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

def SoAudioRenderAction_addMethod(type, method):
    """SoAudioRenderAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoAudioRenderAction_addMethod(type, method)

def SoAudioRenderAction_enableElement(type, stackindex):
    """SoAudioRenderAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoAudioRenderAction_enableElement(type, stackindex)

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

def SoAudioRenderAction_callDoAction(action, node):
    """SoAudioRenderAction_callDoAction(SoAction action, SoNode node)"""
    return _coin.SoAudioRenderAction_callDoAction(action, node)

def SoAudioRenderAction_callAudioRender(action, node):
    """SoAudioRenderAction_callAudioRender(SoAction action, SoNode node)"""
    return _coin.SoAudioRenderAction_callAudioRender(action, node)

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__(SoIntersectingPrimitive 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(SoIntersectionDetectionAction self) -> SoType"""
        return _coin.SoIntersectionDetectionAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoIntersectionDetectionAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoIntersectionDetectionAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoIntersectionDetectionAction 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, epsilon):
        """setIntersectionDetectionEpsilon(SoIntersectionDetectionAction self, float epsilon)"""
        return _coin.SoIntersectionDetectionAction_setIntersectionDetectionEpsilon(self, epsilon)


    def getIntersectionDetectionEpsilon(self):
        """getIntersectionDetectionEpsilon(SoIntersectionDetectionAction self) -> float"""
        return _coin.SoIntersectionDetectionAction_getIntersectionDetectionEpsilon(self)


    def setIntersectionEpsilon(epsilon):
        """setIntersectionEpsilon(float epsilon)"""
        return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon)

    setIntersectionEpsilon = staticmethod(setIntersectionEpsilon)

    def getIntersectionEpsilon():
        """getIntersectionEpsilon() -> float"""
        return _coin.SoIntersectionDetectionAction_getIntersectionEpsilon()

    getIntersectionEpsilon = staticmethod(getIntersectionEpsilon)

    def setTypeEnabled(self, type, enable):
        """setTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setTypeEnabled(self, type, enable)


    def isTypeEnabled(self, type, checkgroups=0):
        """
        isTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool checkgroups=0) -> SbBool
        isTypeEnabled(SoIntersectionDetectionAction self, SoType type) -> SbBool
        """
        return _coin.SoIntersectionDetectionAction_isTypeEnabled(self, type, checkgroups)


    def setManipsEnabled(self, enable):
        """setManipsEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setManipsEnabled(self, enable)


    def isManipsEnabled(self):
        """isManipsEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isManipsEnabled(self)


    def setDraggersEnabled(self, enable):
        """setDraggersEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setDraggersEnabled(self, enable)


    def isDraggersEnabled(self):
        """isDraggersEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isDraggersEnabled(self)


    def setShapeInternalsEnabled(self, enable):
        """setShapeInternalsEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setShapeInternalsEnabled(self, enable)


    def isShapeInternalsEnabled(self):
        """isShapeInternalsEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isShapeInternalsEnabled(self)


    def apply(self, *args):
        """
        apply(SoIntersectionDetectionAction self, SoNode node)
        apply(SoIntersectionDetectionAction self, SoPath path)
        apply(SoIntersectionDetectionAction self, SoPathList paths, SbBool obeysRules=0)
        apply(SoIntersectionDetectionAction self, SoPathList paths)
        """
        return _coin.SoIntersectionDetectionAction_apply(self, *args)


    def addVisitationCallback(self, *args):
        """
        addVisitationCallback(SoIntersectionDetectionAction self, SoType type, SoIntersectionDetectionAction::SoIntersectionVisitationCB * cb, void * closure)
        addVisitationCallback(SoIntersectionDetectionAction self, SoType type, PyObject * pyfunc, PyObject * closure)
        """
        return _coin.SoIntersectionDetectionAction_addVisitationCallback(self, *args)


    def removeVisitationCallback(self, *args):
        """
        removeVisitationCallback(SoIntersectionDetectionAction self, SoType type, SoIntersectionDetectionAction::SoIntersectionVisitationCB * cb, void * closure)
        removeVisitationCallback(SoIntersectionDetectionAction self, SoType type, PyObject * pyfunc, PyObject * closure)
        """
        return _coin.SoIntersectionDetectionAction_removeVisitationCallback(self, *args)


    def setFilterCallback(self, *args):
        """
        setFilterCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionFilterCB * cb, void * closure=None)
        setFilterCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionFilterCB * cb)
        setFilterCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        setFilterCallback(SoIntersectionDetectionAction self, PyObject * pyfunc)
        """
        return _coin.SoIntersectionDetectionAction_setFilterCallback(self, *args)


    def addIntersectionCallback(self, *args):
        """
        addIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)
        addIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb)
        addIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        addIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc)
        """
        return _coin.SoIntersectionDetectionAction_addIntersectionCallback(self, *args)


    def removeIntersectionCallback(self, *args):
        """
        removeIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)
        removeIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb)
        removeIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        removeIntersectionCallback(SoIntersectionDetectionAction 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(type, method):
    """SoIntersectionDetectionAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoIntersectionDetectionAction_addMethod(type, method)

def SoIntersectionDetectionAction_enableElement(type, stackindex):
    """SoIntersectionDetectionAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoIntersectionDetectionAction_enableElement(type, stackindex)

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

def SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon):
    """SoIntersectionDetectionAction_setIntersectionEpsilon(float epsilon)"""
    return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon)

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(SoToVRMLAction self) -> SoType"""
        return _coin.SoToVRMLAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoToVRMLAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoToVRMLAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoToVRMLAction 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(SoToVRMLAction self, SoNode node)
        apply(SoToVRMLAction self, SoPath path)
        apply(SoToVRMLAction self, SoPathList pathlist, SbBool obeysrules=0)
        apply(SoToVRMLAction self, SoPathList pathlist)
        """
        return _coin.SoToVRMLAction_apply(self, *args)


    def getVRMLSceneGraph(self):
        """getVRMLSceneGraph(SoToVRMLAction self) -> SoNode"""
        return _coin.SoToVRMLAction_getVRMLSceneGraph(self)


    def expandSoFile(self, flag):
        """expandSoFile(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_expandSoFile(self, flag)


    def areSoFileExpanded(self):
        """areSoFileExpanded(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areSoFileExpanded(self)


    def setUrlName(self, name):
        """setUrlName(SoToVRMLAction self, SbString name)"""
        return _coin.SoToVRMLAction_setUrlName(self, name)


    def getUrlName(self):
        """getUrlName(SoToVRMLAction self) -> SbString"""
        return _coin.SoToVRMLAction_getUrlName(self)


    def writeTexCoords(self, flag):
        """writeTexCoords(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_writeTexCoords(self, flag)


    def areTexCoordWritten(self):
        """areTexCoordWritten(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areTexCoordWritten(self)


    def expandTexture2Node(self, flag):
        """expandTexture2Node(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_expandTexture2Node(self, flag)


    def areTexture2NodeExpanded(self):
        """areTexture2NodeExpanded(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areTexture2NodeExpanded(self)


    def keepUnknownNodes(self, flag):
        """keepUnknownNodes(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_keepUnknownNodes(self, flag)


    def areUnknownNodeKept(self):
        """areUnknownNodeKept(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areUnknownNodeKept(self)


    def convertInlineNodes(self, flag):
        """convertInlineNodes(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_convertInlineNodes(self, flag)


    def doConvertInlineNodes(self):
        """doConvertInlineNodes(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_doConvertInlineNodes(self)


    def conditionalConversion(self, flag):
        """conditionalConversion(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_conditionalConversion(self, flag)


    def doConditionalConversion(self):
        """doConditionalConversion(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_doConditionalConversion(self)


    def setVerbosity(self, flag):
        """setVerbosity(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_setVerbosity(self, flag)


    def isVerbose(self):
        """isVerbose(SoToVRMLAction 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(type, method):
    """SoToVRMLAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoToVRMLAction_addMethod(type, method)

def SoToVRMLAction_enableElement(type, stackindex):
    """SoToVRMLAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoToVRMLAction_enableElement(type, stackindex)

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(SoToVRML2Action self) -> SoType"""
        return _coin.SoToVRML2Action_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoToVRML2Action_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoToVRML2Action_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoToVRML2Action 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(SoToVRML2Action self, SoNode node)
        apply(SoToVRML2Action self, SoPath path)
        apply(SoToVRML2Action self, SoPathList pathlist, SbBool obeysrules=0)
        apply(SoToVRML2Action self, SoPathList pathlist)
        """
        return _coin.SoToVRML2Action_apply(self, *args)


    def getVRML2SceneGraph(self):
        """getVRML2SceneGraph(SoToVRML2Action self) -> SoVRMLGroup"""
        return _coin.SoToVRML2Action_getVRML2SceneGraph(self)


    def reuseAppearanceNodes(self, appearance):
        """reuseAppearanceNodes(SoToVRML2Action self, SbBool appearance)"""
        return _coin.SoToVRML2Action_reuseAppearanceNodes(self, appearance)


    def doReuseAppearanceNodes(self):
        """doReuseAppearanceNodes(SoToVRML2Action self) -> SbBool"""
        return _coin.SoToVRML2Action_doReuseAppearanceNodes(self)


    def reusePropertyNodes(self, property):
        """reusePropertyNodes(SoToVRML2Action self, SbBool property)"""
        return _coin.SoToVRML2Action_reusePropertyNodes(self, property)


    def doReusePropertyNodes(self):
        """doReusePropertyNodes(SoToVRML2Action self) -> SbBool"""
        return _coin.SoToVRML2Action_doReusePropertyNodes(self)


    def reuseGeometryNodes(self, geometry):
        """reuseGeometryNodes(SoToVRML2Action self, SbBool geometry)"""
        return _coin.SoToVRML2Action_reuseGeometryNodes(self, geometry)


    def doReuseGeometryNodes(self):
        """doReuseGeometryNodes(SoToVRML2Action 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(type, method):
    """SoToVRML2Action_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoToVRML2Action_addMethod(type, method)

def SoToVRML2Action_enableElement(type, stackindex):
    """SoToVRML2Action_enableElement(SoType type, int const stackindex)"""
    return _coin.SoToVRML2Action_enableElement(type, stackindex)

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 const *"""
        return _coin.SoHardCopy_getProductName()

    getProductName = staticmethod(getProductName)

    def getVersion():
        """getVersion() -> char const *"""
        return _coin.SoHardCopy_getVersion()

    getVersion = staticmethod(getVersion)

    def __init__(self):
        """__init__(SoHardCopy 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 const *"""
    return _coin.SoHardCopy_getProductName()

def SoHardCopy_getVersion():
    """SoHardCopy_getVersion() -> char const *"""
    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__(SoVectorOutput 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, filename):
        """openFile(SoVectorOutput self, char const * filename) -> SbBool"""
        return _coin.SoVectorOutput_openFile(self, filename)


    def closeFile(self):
        """closeFile(SoVectorOutput self)"""
        return _coin.SoVectorOutput_closeFile(self)


    def getFilePointer(self):
        """getFilePointer(SoVectorOutput 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__(SoPSVectorOutput 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(SoPSVectorOutput self, SbBool flag=1)
        setColored(SoPSVectorOutput self)
        """
        return _coin.SoPSVectorOutput_setColored(self, flag)


    def getColored(self):
        """getColored(SoPSVectorOutput 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(SoVectorizeAction self) -> SoType"""
        return _coin.SoVectorizeAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoVectorizeAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoVectorizeAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)
    __swig_destroy__ = _coin.delete_SoVectorizeAction
    __del__ = lambda self: None

    def getOutput(self):
        """getOutput(SoVectorizeAction 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(SoVectorizeAction self, SoNode node)
        apply(SoVectorizeAction self, SoPath path)
        apply(SoVectorizeAction self, SoPathList pathlist, SbBool obeysrules=0)
        apply(SoVectorizeAction self, SoPathList pathlist)
        """
        return _coin.SoVectorizeAction_apply(self, *args)


    def beginStandardPage(self, pagesize, border=10.0):
        """
        beginStandardPage(SoVectorizeAction self, SoVectorizeAction::PageSize const & pagesize, float const border=10.0)
        beginStandardPage(SoVectorizeAction self, SoVectorizeAction::PageSize const & pagesize)
        """
        return _coin.SoVectorizeAction_beginStandardPage(self, pagesize, border)


    def beginPage(self, *args):
        """
        beginPage(SoVectorizeAction self, SbVec2f startpagepos, SbVec2f pagesize, SoVectorizeAction::DimensionUnit u)
        beginPage(SoVectorizeAction self, SbVec2f startpagepos, SbVec2f pagesize)
        """
        return _coin.SoVectorizeAction_beginPage(self, *args)


    def endPage(self):
        """endPage(SoVectorizeAction self)"""
        return _coin.SoVectorizeAction_endPage(self)


    def calibrate(self, vp):
        """calibrate(SoVectorizeAction self, SbViewportRegion vp)"""
        return _coin.SoVectorizeAction_calibrate(self, vp)


    def beginViewport(self, *args):
        """
        beginViewport(SoVectorizeAction self, SbVec2f startpos, SbVec2f size, SoVectorizeAction::DimensionUnit u)
        beginViewport(SoVectorizeAction self, SbVec2f startpos, SbVec2f size)
        beginViewport(SoVectorizeAction self, SbVec2f startpos)
        beginViewport(SoVectorizeAction self)
        """
        return _coin.SoVectorizeAction_beginViewport(self, *args)


    def endViewport(self):
        """endViewport(SoVectorizeAction self)"""
        return _coin.SoVectorizeAction_endViewport(self)


    def setOrientation(self, o):
        """setOrientation(SoVectorizeAction self, SoVectorizeAction::Orientation o)"""
        return _coin.SoVectorizeAction_setOrientation(self, o)


    def getOrientation(self):
        """getOrientation(SoVectorizeAction self) -> SoVectorizeAction::Orientation"""
        return _coin.SoVectorizeAction_getOrientation(self)


    def setBackgroundColor(self, *args):
        """
        setBackgroundColor(SoVectorizeAction self, SbBool bg, SbColor col)
        setBackgroundColor(SoVectorizeAction self, SbBool bg)
        """
        return _coin.SoVectorizeAction_setBackgroundColor(self, *args)


    def getBackgroundColor(self, col):
        """getBackgroundColor(SoVectorizeAction self, SbColor col) -> SbBool"""
        return _coin.SoVectorizeAction_getBackgroundColor(self, col)


    def setNominalWidth(self, *args):
        """
        setNominalWidth(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u)
        setNominalWidth(SoVectorizeAction self, float w)
        """
        return _coin.SoVectorizeAction_setNominalWidth(self, *args)


    def getNominalWidth(self, *args):
        """
        getNominalWidth(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u) -> float
        getNominalWidth(SoVectorizeAction self) -> float
        """
        return _coin.SoVectorizeAction_getNominalWidth(self, *args)


    def setPixelImageSize(self, *args):
        """
        setPixelImageSize(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u)
        setPixelImageSize(SoVectorizeAction self, float w)
        """
        return _coin.SoVectorizeAction_setPixelImageSize(self, *args)


    def getPixelImageSize(self, *args):
        """
        getPixelImageSize(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u) -> float
        getPixelImageSize(SoVectorizeAction self) -> float
        """
        return _coin.SoVectorizeAction_getPixelImageSize(self, *args)

    CIRCLE = _coin.SoVectorizeAction_CIRCLE
    SQUARE = _coin.SoVectorizeAction_SQUARE

    def setPointStyle(self, style):
        """setPointStyle(SoVectorizeAction self, SoVectorizeAction::PointStyle const & style)"""
        return _coin.SoVectorizeAction_setPointStyle(self, style)


    def getPointStyle(self):
        """getPointStyle(SoVectorizeAction self) -> SoVectorizeAction::PointStyle"""
        return _coin.SoVectorizeAction_getPointStyle(self)


    def getPageStartpos(self):
        """getPageStartpos(SoVectorizeAction self) -> SbVec2f"""
        return _coin.SoVectorizeAction_getPageStartpos(self)


    def getPageSize(self):
        """getPageSize(SoVectorizeAction 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(SoVectorizeAction self, SbVec2f d, SoVectorizeAction::DimensionUnit u)
        setDrawingDimensions(SoVectorizeAction self, SbVec2f d)
        setDrawingDimensions(SoVectorizeAction self, float w, float h, SoVectorizeAction::DimensionUnit u)
        setDrawingDimensions(SoVectorizeAction self, float w, float h)
        """
        return _coin.SoVectorizeAction_setDrawingDimensions(self, *args)


    def getDrawingDimensions(self, *args):
        """
        getDrawingDimensions(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u) -> SbVec2f
        getDrawingDimensions(SoVectorizeAction self) -> SbVec2f
        """
        return _coin.SoVectorizeAction_getDrawingDimensions(self, *args)


    def setStartPosition(self, *args):
        """
        setStartPosition(SoVectorizeAction self, SbVec2f p, SoVectorizeAction::DimensionUnit u)
        setStartPosition(SoVectorizeAction self, SbVec2f p)
        setStartPosition(SoVectorizeAction self, float x, float y, SoVectorizeAction::DimensionUnit u)
        setStartPosition(SoVectorizeAction self, float x, float y)
        """
        return _coin.SoVectorizeAction_setStartPosition(self, *args)


    def getStartPosition(self, *args):
        """
        getStartPosition(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u) -> SbVec2f
        getStartPosition(SoVectorizeAction self) -> SbVec2f
        """
        return _coin.SoVectorizeAction_getStartPosition(self, *args)


    def setColorTranslationMethod(self, method):
        """setColorTranslationMethod(SoVectorizeAction self, SoVectorizeAction::ColorTranslationMethod method)"""
        return _coin.SoVectorizeAction_setColorTranslationMethod(self, method)


    def getColorTranslationMethod(self):
        """getColorTranslationMethod(SoVectorizeAction self) -> SoVectorizeAction::ColorTranslationMethod"""
        return _coin.SoVectorizeAction_getColorTranslationMethod(self)


    def setLineEndStyle(self, style):
        """setLineEndStyle(SoVectorizeAction self, SoVectorizeAction::EndLineStyle style)"""
        return _coin.SoVectorizeAction_setLineEndStyle(self, style)


    def getLineEndStyle(self):
        """getLineEndStyle(SoVectorizeAction self) -> SoVectorizeAction::EndLineStyle"""
        return _coin.SoVectorizeAction_getLineEndStyle(self)


    def setLineJoinsStyle(self, style):
        """setLineJoinsStyle(SoVectorizeAction self, SoVectorizeAction::JoinLineStyle style)"""
        return _coin.SoVectorizeAction_setLineJoinsStyle(self, style)


    def getLineJoinsStyle(self):
        """getLineJoinsStyle(SoVectorizeAction self) -> SoVectorizeAction::JoinLineStyle"""
        return _coin.SoVectorizeAction_getLineJoinsStyle(self)


    def setHLHSRMode(self, mode):
        """setHLHSRMode(SoVectorizeAction self, SoVectorizeAction::HLHSRMode mode)"""
        return _coin.SoVectorizeAction_setHLHSRMode(self, mode)


    def getHLHSRMode(self):
        """getHLHSRMode(SoVectorizeAction self) -> SoVectorizeAction::HLHSRMode"""
        return _coin.SoVectorizeAction_getHLHSRMode(self)


    def setBorder(self, *args):
        """
        setBorder(SoVectorizeAction self, float width)
        setBorder(SoVectorizeAction self, float width, SbColor color)
        """
        return _coin.SoVectorizeAction_setBorder(self, *args)


    def setMiterLimit(self, limit):
        """setMiterLimit(SoVectorizeAction self, float limit)"""
        return _coin.SoVectorizeAction_setMiterLimit(self, limit)


    def getMiterLimit(self):
        """getMiterLimit(SoVectorizeAction self) -> float"""
        return _coin.SoVectorizeAction_getMiterLimit(self)


    def setPenDescription(self, *args):
        """
        setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None, float const * widths=None, SoVectorizeAction::DimensionUnit u)
        setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None, float const * widths=None)
        setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None)
        setPenDescription(SoVectorizeAction self, int num_pens)
        """
        return _coin.SoVectorizeAction_setPenDescription(self, *args)


    def getPenDescription(self, *args):
        """
        getPenDescription(SoVectorizeAction self, SbColor colors, float * widths, SoVectorizeAction::DimensionUnit u)
        getPenDescription(SoVectorizeAction self, SbColor colors, float * widths)
        """
        return _coin.SoVectorizeAction_getPenDescription(self, *args)


    def getPenNum(self):
        """getPenNum(SoVectorizeAction self) -> int"""
        return _coin.SoVectorizeAction_getPenNum(self)


    def setColorPriority(self, priority):
        """setColorPriority(SoVectorizeAction self, SbBool priority)"""
        return _coin.SoVectorizeAction_setColorPriority(self, priority)


    def getColorPriority(self):
        """getColorPriority(SoVectorizeAction self) -> SbBool"""
        return _coin.SoVectorizeAction_getColorPriority(self)


    def enableLighting(self, flag):
        """enableLighting(SoVectorizeAction self, SbBool flag)"""
        return _coin.SoVectorizeAction_enableLighting(self, flag)


    def isLightingEnabled(self):
        """isLightingEnabled(SoVectorizeAction 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(type, method):
    """SoVectorizeAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoVectorizeAction_addMethod(type, method)

def SoVectorizeAction_enableElement(type, stackindex):
    """SoVectorizeAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoVectorizeAction_enableElement(type, stackindex)

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(SoShape 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(SoShape self) -> SbBool"""
        return _coin.SoShape_affectsState(self)


    def notify(self, nl):
        """notify(SoShape self, SoNotList nl)"""
        return _coin.SoShape_notify(self, nl)


    def getBoundingBox(self, action):
        """getBoundingBox(SoShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoShape_getBoundingBox(self, action)


    def GLRender(self, action):
        """GLRender(SoShape self, SoGLRenderAction action)"""
        return _coin.SoShape_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoShape self, SoRayPickAction action)"""
        return _coin.SoShape_rayPick(self, action)


    def callback(self, action):
        """callback(SoShape self, SoCallbackAction action)"""
        return _coin.SoShape_callback(self, action)


    def computeBBox(self, action, box, center):
        """computeBBox(SoShape self, SoAction action, SbBox3f box, SbVec3f center)"""
        return _coin.SoShape_computeBBox(self, action, box, center)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoShape self, SoGetPrimitiveCountAction action)"""
        return _coin.SoShape_getPrimitiveCount(self, action)


    def getScreenSize(state, boundingbox, rectsize):
        """getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
        return _coin.SoShape_getScreenSize(state, boundingbox, rectsize)

    getScreenSize = staticmethod(getScreenSize)

    def getDecimatedComplexity(state, complexity):
        """getDecimatedComplexity(SoState state, float complexity) -> float"""
        return _coin.SoShape_getDecimatedComplexity(state, complexity)

    getDecimatedComplexity = staticmethod(getDecimatedComplexity)

    def getBoundingBoxCache(self):
        """getBoundingBoxCache(SoShape 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(state, boundingbox, rectsize):
    """SoShape_getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
    return _coin.SoShape_getScreenSize(state, boundingbox, rectsize)

def SoShape_getDecimatedComplexity(state, complexity):
    """SoShape_getDecimatedComplexity(SoState state, float complexity) -> float"""
    return _coin.SoShape_getDecimatedComplexity(state, complexity)

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(SoImage self) -> SoType"""
        return _coin.SoImage_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoImage 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, action):
        """GLRender(SoImage self, SoGLRenderAction action)"""
        return _coin.SoImage_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoImage self, SoRayPickAction action)"""
        return _coin.SoImage_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoImage self, SoGetPrimitiveCountAction action)"""
        return _coin.SoImage_getPrimitiveCount(self, action)

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(SoVectorizePSAction self) -> SoType"""
        return _coin.SoVectorizePSAction_getTypeId(self)


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

    getClassTypeId = staticmethod(getClassTypeId)

    def addMethod(type, method):
        """addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoVectorizePSAction_addMethod(type, method)

    addMethod = staticmethod(addMethod)

    def enableElement(type, stackindex):
        """enableElement(SoType type, int const stackindex)"""
        return _coin.SoVectorizePSAction_enableElement(type, stackindex)

    enableElement = staticmethod(enableElement)

    def __init__(self):
        """__init__(SoVectorizePSAction 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, fontname):
        """setDefault2DFont(SoVectorizePSAction self, SbString fontname)"""
        return _coin.SoVectorizePSAction_setDefault2DFont(self, fontname)


    def getDefault2DFont(self):
        """getDefault2DFont(SoVectorizePSAction self) -> SbString"""
        return _coin.SoVectorizePSAction_getDefault2DFont(self)


    def setGouraudThreshold(self, eps):
        """setGouraudThreshold(SoVectorizePSAction self, double const eps)"""
        return _coin.SoVectorizePSAction_setGouraudThreshold(self, eps)


    def getOutput(self):
        """getOutput(SoVectorizePSAction self) -> SoPSVectorOutput"""
        return _coin.SoVectorizePSAction_getOutput(self)


    def getPSOutput(self):
        """getPSOutput(SoVectorizePSAction 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(type, method):
    """SoVectorizePSAction_addMethod(SoType type, SoActionMethod method)"""
    return _coin.SoVectorizePSAction_addMethod(type, method)

def SoVectorizePSAction_enableElement(type, stackindex):
    """SoVectorizePSAction_enableElement(SoType type, int const stackindex)"""
    return _coin.SoVectorizePSAction_enableElement(type, stackindex)

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, action):
        """__init__(SoMaterialBundle self, SoAction action) -> SoMaterialBundle"""
        this = _coin.new_SoMaterialBundle(action)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoMaterialBundle
    __del__ = lambda self: None

    def setUpMultiple(self):
        """setUpMultiple(SoMaterialBundle self)"""
        return _coin.SoMaterialBundle_setUpMultiple(self)


    def sendFirst(self):
        """sendFirst(SoMaterialBundle self)"""
        return _coin.SoMaterialBundle_sendFirst(self)


    def forceSend(self, index):
        """forceSend(SoMaterialBundle self, int const index)"""
        return _coin.SoMaterialBundle_forceSend(self, index)


    def isColorOnly(self):
        """isColorOnly(SoMaterialBundle self) -> SbBool"""
        return _coin.SoMaterialBundle_isColorOnly(self)


    def send(self, index, betweenbeginend):
        """send(SoMaterialBundle self, int const index, SbBool const betweenbeginend)"""
        return _coin.SoMaterialBundle_send(self, index, betweenbeginend)

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__(SbBSPTree self, int const maxnodepts=64, int const initsize=4) -> SbBSPTree
        __init__(SbBSPTree self, int const maxnodepts=64) -> SbBSPTree
        __init__(SbBSPTree 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(SbBSPTree self) -> int"""
        return _coin.SbBSPTree_numPoints(self)


    def getPoint(self, *args):
        """
        getPoint(SbBSPTree self, int const idx) -> SbVec3f
        getPoint(SbBSPTree self, int const idx, SbVec3f pt)
        """
        return _coin.SbBSPTree_getPoint(self, *args)


    def getUserData(self, idx):
        """getUserData(SbBSPTree self, int const idx) -> void *"""
        return _coin.SbBSPTree_getUserData(self, idx)


    def setUserData(self, idx, data):
        """setUserData(SbBSPTree self, int const idx, void *const data)"""
        return _coin.SbBSPTree_setUserData(self, idx, data)


    def addPoint(self, pt, userdata=None):
        """
        addPoint(SbBSPTree self, SbVec3f pt, void *const userdata=None) -> int
        addPoint(SbBSPTree self, SbVec3f pt) -> int
        """
        return _coin.SbBSPTree_addPoint(self, pt, userdata)


    def removePoint(self, *args):
        """
        removePoint(SbBSPTree self, SbVec3f pt) -> int
        removePoint(SbBSPTree self, int const idx)
        """
        return _coin.SbBSPTree_removePoint(self, *args)


    def findPoint(self, pos):
        """findPoint(SbBSPTree self, SbVec3f pos) -> int"""
        return _coin.SbBSPTree_findPoint(self, pos)


    def clear(self, initsize=4):
        """
        clear(SbBSPTree self, int const initsize=4)
        clear(SbBSPTree self)
        """
        return _coin.SbBSPTree_clear(self, initsize)


    def getBBox(self):
        """getBBox(SbBSPTree self) -> SbBox3f"""
        return _coin.SbBSPTree_getBBox(self)


    def getPointsArrayPtr(self):
        """getPointsArrayPtr(SbBSPTree self) -> SbVec3f"""
        return _coin.SbBSPTree_getPointsArrayPtr(self)


    def findPoints(self, *args):
        """
        findPoints(SbBSPTree self, SbSphere sphere, SbIntList array)
        findPoints(SbBSPTree self, SbSphere sphere, SbList< int > & array)
        """
        return _coin.SbBSPTree_findPoints(self, *args)


    def findClosest(self, *args):
        """
        findClosest(SbBSPTree self, SbVec3f pos) -> int
        findClosest(SbBSPTree self, SbSphere sphere, SbIntList array) -> int
        findClosest(SbBSPTree 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, ccw, approxVertices=64):
        """
        __init__(SoNormalGenerator self, SbBool const ccw, int const approxVertices=64) -> SoNormalGenerator
        __init__(SoNormalGenerator self, SbBool const ccw) -> SoNormalGenerator
        """
        this = _coin.new_SoNormalGenerator(ccw, approxVertices)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoNormalGenerator
    __del__ = lambda self: None

    def reset(self, ccw):
        """reset(SoNormalGenerator self, SbBool const ccw)"""
        return _coin.SoNormalGenerator_reset(self, ccw)


    def beginPolygon(self):
        """beginPolygon(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_beginPolygon(self)


    def polygonVertex(self, v):
        """polygonVertex(SoNormalGenerator self, SbVec3f v)"""
        return _coin.SoNormalGenerator_polygonVertex(self, v)


    def endPolygon(self):
        """endPolygon(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_endPolygon(self)


    def triangle(self, v0, v1, v2):
        """triangle(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2)"""
        return _coin.SoNormalGenerator_triangle(self, v0, v1, v2)


    def quad(self, v0, v1, v2, v3):
        """quad(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f v3)"""
        return _coin.SoNormalGenerator_quad(self, v0, v1, v2, v3)


    def generate(self, creaseAngle, striplens=None, numstrips=0):
        """
        generate(SoNormalGenerator self, float const creaseAngle, int32_t const * striplens=None, int const numstrips=0)
        generate(SoNormalGenerator self, float const creaseAngle, int32_t const * striplens=None)
        generate(SoNormalGenerator self, float const creaseAngle)
        """
        return _coin.SoNormalGenerator_generate(self, creaseAngle, striplens, numstrips)


    def generatePerStrip(self, striplens, numstrips):
        """generatePerStrip(SoNormalGenerator self, int32_t const * striplens, int const numstrips)"""
        return _coin.SoNormalGenerator_generatePerStrip(self, striplens, numstrips)


    def generatePerFace(self):
        """generatePerFace(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_generatePerFace(self)


    def generateOverall(self):
        """generateOverall(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_generateOverall(self)


    def getNumNormals(self):
        """getNumNormals(SoNormalGenerator self) -> int"""
        return _coin.SoNormalGenerator_getNumNormals(self)


    def setNumNormals(self, num):
        """setNumNormals(SoNormalGenerator self, int const num)"""
        return _coin.SoNormalGenerator_setNumNormals(self, num)


    def getNormals(self):
        """getNormals(SoNormalGenerator self) -> SbVec3f"""
        return _coin.SoNormalGenerator_getNormals(self)


    def getNormal(self, i):
        """getNormal(SoNormalGenerator self, int32_t const i) -> SbVec3f"""
        return _coin.SoNormalGenerator_getNormal(self, i)


    def setNormal(self, index, normal):
        """setNormal(SoNormalGenerator self, int32_t const index, SbVec3f normal)"""
        return _coin.SoNormalGenerator_setNormal(self, index, normal)

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, state):
        """init(SoNormalElement self, SoState state)"""
        return _coin.SoNormalElement_init(self, state)


    def set(state, node, numNormals, normals, normalsAreUnitLength=0):
        """
        set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals, SbBool const normalsAreUnitLength=0)
        set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals)
        """
        return _coin.SoNormalElement_set(state, node, numNormals, normals, normalsAreUnitLength)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoNormalElement"""
        return _coin.SoNormalElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoNormalElement self) -> int32_t"""
        return _coin.SoNormalElement_getNum(self)


    def get(self, index):
        """get(SoNormalElement self, int const index) -> SbVec3f"""
        return _coin.SoNormalElement_get(self, index)


    def getArrayPtr(self):
        """getArrayPtr(SoNormalElement self) -> SbVec3f"""
        return _coin.SoNormalElement_getArrayPtr(self)


    def areNormalsUnitLength(self):
        """areNormalsUnitLength(SoNormalElement 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(state, node, numNormals, normals, normalsAreUnitLength=0):
    """
    set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals, SbBool const normalsAreUnitLength=0)
    SoNormalElement_set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals)
    """
    return _coin.SoNormalElement_set(state, node, numNormals, normals, normalsAreUnitLength)

def SoNormalElement_getInstance(state):
    """SoNormalElement_getInstance(SoState state) -> SoNormalElement"""
    return _coin.SoNormalElement_getInstance(state)

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, state):
        """init(SoGLNormalElement self, SoState state)"""
        return _coin.SoGLNormalElement_init(self, state)


    def send(self, index):
        """send(SoGLNormalElement self, int const index)"""
        return _coin.SoGLNormalElement_send(self, index)

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, state):
        """init(SoTextureCoordinateElement self, SoState state)"""
        return _coin.SoTextureCoordinateElement_init(self, state)


    def setDefault(state, node):
        """setDefault(SoState state, SoNode node)"""
        return _coin.SoTextureCoordinateElement_setDefault(state, node)

    setDefault = staticmethod(setDefault)

    def setFunction(state, node, func, userdata):
        """setFunction(SoState state, SoNode node, SoTextureCoordinateFunctionCB *const func, void *const userdata)"""
        return _coin.SoTextureCoordinateElement_setFunction(state, node, func, userdata)

    setFunction = staticmethod(setFunction)

    def set2(state, node, numCoords, coords):
        """set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"""
        return _coin.SoTextureCoordinateElement_set2(state, node, numCoords, coords)

    set2 = staticmethod(set2)

    def set3(state, node, numCoords, coords):
        """set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoTextureCoordinateElement_set3(state, node, numCoords, coords)

    set3 = staticmethod(set3)

    def set4(state, node, numCoords, coords):
        """set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
        return _coin.SoTextureCoordinateElement_set4(state, node, numCoords, coords)

    set4 = staticmethod(set4)

    def getType(self, *args):
        """
        getType(SoTextureCoordinateElement self, SoState state) -> SoTextureCoordinateElement::CoordType
        getType(SoTextureCoordinateElement self) -> SoTextureCoordinateElement::CoordType
        """
        return _coin.SoTextureCoordinateElement_getType(self, *args)


    def getInstance(state):
        """getInstance(SoState state) -> SoTextureCoordinateElement"""
        return _coin.SoTextureCoordinateElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def get(self, point, normal):
        """get(SoTextureCoordinateElement self, SbVec3f point, SbVec3f normal) -> SbVec4f"""
        return _coin.SoTextureCoordinateElement_get(self, point, normal)


    def getNum(self):
        """getNum(SoTextureCoordinateElement self) -> int32_t"""
        return _coin.SoTextureCoordinateElement_getNum(self)


    def is2D(self):
        """is2D(SoTextureCoordinateElement self) -> SbBool"""
        return _coin.SoTextureCoordinateElement_is2D(self)


    def getDimension(self):
        """getDimension(SoTextureCoordinateElement self) -> int32_t"""
        return _coin.SoTextureCoordinateElement_getDimension(self)


    def get2(self, index):
        """get2(SoTextureCoordinateElement self, int const index) -> SbVec2f"""
        return _coin.SoTextureCoordinateElement_get2(self, index)


    def get3(self, index):
        """get3(SoTextureCoordinateElement self, int const index) -> SbVec3f"""
        return _coin.SoTextureCoordinateElement_get3(self, index)


    def get4(self, index):
        """get4(SoTextureCoordinateElement self, int const index) -> SbVec4f"""
        return _coin.SoTextureCoordinateElement_get4(self, index)


    def getArrayPtr2(self):
        """getArrayPtr2(SoTextureCoordinateElement self) -> SbVec2f"""
        return _coin.SoTextureCoordinateElement_getArrayPtr2(self)


    def getArrayPtr3(self):
        """getArrayPtr3(SoTextureCoordinateElement self) -> SbVec3f"""
        return _coin.SoTextureCoordinateElement_getArrayPtr3(self)


    def getArrayPtr4(self):
        """getArrayPtr4(SoTextureCoordinateElement 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(state, node):
    """SoTextureCoordinateElement_setDefault(SoState state, SoNode node)"""
    return _coin.SoTextureCoordinateElement_setDefault(state, node)

def SoTextureCoordinateElement_setFunction(state, node, func, userdata):
    """SoTextureCoordinateElement_setFunction(SoState state, SoNode node, SoTextureCoordinateFunctionCB *const func, void *const userdata)"""
    return _coin.SoTextureCoordinateElement_setFunction(state, node, func, userdata)

def SoTextureCoordinateElement_set2(state, node, numCoords, coords):
    """SoTextureCoordinateElement_set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"""
    return _coin.SoTextureCoordinateElement_set2(state, node, numCoords, coords)

def SoTextureCoordinateElement_set3(state, node, numCoords, coords):
    """SoTextureCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
    return _coin.SoTextureCoordinateElement_set3(state, node, numCoords, coords)

def SoTextureCoordinateElement_set4(state, node, numCoords, coords):
    """SoTextureCoordinateElement_set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
    return _coin.SoTextureCoordinateElement_set4(state, node, numCoords, coords)

def SoTextureCoordinateElement_getInstance(state):
    """SoTextureCoordinateElement_getInstance(SoState state) -> SoTextureCoordinateElement"""
    return _coin.SoTextureCoordinateElement_getInstance(state)

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, state):
        """init(SoGLTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_init(self, state)


    def push(self, state):
        """push(SoGLTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLTextureCoordinateElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureCoordinateElement_pop(self, state, prevTopElement)


    def setTexGen(state, node, texgenFunc, texgenData=None, func=None, funcData=None):
        """
        setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc, void *const texgenData=None, SoTextureCoordinateFunctionCB *const func=None, void *const funcData=None)
        setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc, void *const texgenData=None, SoTextureCoordinateFunctionCB *const func=None)
        setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc, void *const texgenData=None)
        setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc)
        """
        return _coin.SoGLTextureCoordinateElement_setTexGen(state, node, texgenFunc, texgenData, func, funcData)

    setTexGen = staticmethod(setTexGen)

    def getType(self):
        """getType(SoGLTextureCoordinateElement self) -> SoTextureCoordinateElement::CoordType"""
        return _coin.SoGLTextureCoordinateElement_getType(self)


    def getInstance(state):
        """getInstance(SoState state) -> SoGLTextureCoordinateElement"""
        return _coin.SoGLTextureCoordinateElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def send(self, *args):
        """
        send(SoGLTextureCoordinateElement self, int const index)
        send(SoGLTextureCoordinateElement self, int const index, SbVec3f c, SbVec3f n)
        """
        return _coin.SoGLTextureCoordinateElement_send(self, *args)


    def initMulti(self, state):
        """initMulti(SoGLTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_initMulti(self, state)

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(state, node, texgenFunc, texgenData=None, func=None, funcData=None):
    """
    setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc, void *const texgenData=None, SoTextureCoordinateFunctionCB *const func=None, void *const funcData=None)
    setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc, void *const texgenData=None, SoTextureCoordinateFunctionCB *const func=None)
    setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc, void *const texgenData=None)
    SoGLTextureCoordinateElement_setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc)
    """
    return _coin.SoGLTextureCoordinateElement_setTexGen(state, node, texgenFunc, texgenData, func, funcData)

def SoGLTextureCoordinateElement_getInstance(state):
    """SoGLTextureCoordinateElement_getInstance(SoState state) -> SoGLTextureCoordinateElement"""
    return _coin.SoGLTextureCoordinateElement_getInstance(state)

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, action, forRendering, setUpDefault=1):
        """
        __init__(SoTextureCoordinateBundle self, SoAction action, SbBool const forRendering, SbBool const setUpDefault=1) -> SoTextureCoordinateBundle
        __init__(SoTextureCoordinateBundle self, SoAction action, SbBool const forRendering) -> SoTextureCoordinateBundle
        """
        this = _coin.new_SoTextureCoordinateBundle(action, forRendering, setUpDefault)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoTextureCoordinateBundle
    __del__ = lambda self: None

    def needCoordinates(self):
        """needCoordinates(SoTextureCoordinateBundle self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_needCoordinates(self)


    def isFunction(self):
        """isFunction(SoTextureCoordinateBundle self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_isFunction(self)


    def get(self, *args):
        """
        get(SoTextureCoordinateBundle self, int const index) -> SbVec4f
        get(SoTextureCoordinateBundle self, SbVec3f point, SbVec3f normal) -> SbVec4f
        """
        return _coin.SoTextureCoordinateBundle_get(self, *args)


    def send(self, *args):
        """
        send(SoTextureCoordinateBundle self, int const index)
        send(SoTextureCoordinateBundle self, int const index, SbVec3f point, SbVec3f normal)
        """
        return _coin.SoTextureCoordinateBundle_send(self, *args)


    def needIndices(self):
        """needIndices(SoTextureCoordinateBundle 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, state):
        """__init__(SoCache self, SoState state) -> SoCache"""
        this = _coin.new_SoCache(state)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ref(self):
        """ref(SoCache self)"""
        return _coin.SoCache_ref(self)


    def unref(self, state=None):
        """
        unref(SoCache self, SoState state=None)
        unref(SoCache self)
        """
        return _coin.SoCache_unref(self, state)


    def addElement(self, elem):
        """addElement(SoCache self, SoElement elem)"""
        return _coin.SoCache_addElement(self, elem)


    def addCacheDependency(self, state, cache):
        """addCacheDependency(SoCache self, SoState state, SoCache cache)"""
        return _coin.SoCache_addCacheDependency(self, state, cache)


    def isValid(self, state):
        """isValid(SoCache self, SoState state) -> SbBool"""
        return _coin.SoCache_isValid(self, state)


    def getInvalidElement(self, state):
        """getInvalidElement(SoCache self, SoState state) -> SoElement"""
        return _coin.SoCache_getInvalidElement(self, state)


    def invalidate(self):
        """invalidate(SoCache 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, state):
        """__init__(SoBoundingBoxCache self, SoState state) -> SoBoundingBoxCache"""
        this = _coin.new_SoBoundingBoxCache(state)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoBoundingBoxCache
    __del__ = lambda self: None

    def set(self, boundingbox, centerset, centerpoint):
        """set(SoBoundingBoxCache self, SbXfBox3f boundingbox, SbBool centerset, SbVec3f centerpoint)"""
        return _coin.SoBoundingBoxCache_set(self, boundingbox, centerset, centerpoint)


    def getBox(self):
        """getBox(SoBoundingBoxCache self) -> SbXfBox3f"""
        return _coin.SoBoundingBoxCache_getBox(self)


    def getProjectedBox(self):
        """getProjectedBox(SoBoundingBoxCache self) -> SbBox3f"""
        return _coin.SoBoundingBoxCache_getProjectedBox(self)


    def isCenterSet(self):
        """isCenterSet(SoBoundingBoxCache self) -> SbBool"""
        return _coin.SoBoundingBoxCache_isCenterSet(self)


    def getCenter(self):
        """getCenter(SoBoundingBoxCache self) -> SbVec3f"""
        return _coin.SoBoundingBoxCache_getCenter(self)


    def setHasLinesOrPoints(state):
        """setHasLinesOrPoints(SoState state)"""
        return _coin.SoBoundingBoxCache_setHasLinesOrPoints(state)

    setHasLinesOrPoints = staticmethod(setHasLinesOrPoints)

    def hasLinesOrPoints(self):
        """hasLinesOrPoints(SoBoundingBoxCache self) -> SbBool"""
        return _coin.SoBoundingBoxCache_hasLinesOrPoints(self)

SoBoundingBoxCache_swigregister = _coin.SoBoundingBoxCache_swigregister
SoBoundingBoxCache_swigregister(SoBoundingBoxCache)

def SoBoundingBoxCache_setHasLinesOrPoints(state):
    """SoBoundingBoxCache_setHasLinesOrPoints(SoState state)"""
    return _coin.SoBoundingBoxCache_setHasLinesOrPoints(state)

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, state):
        """__init__(SoConvexDataCache self, SoState state) -> SoConvexDataCache"""
        this = _coin.new_SoConvexDataCache(state)
        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, coords, coordindices, numcoordindices, matindices, normindices, texindices, matbinding, normbinding, texbinding):
        """generate(SoConvexDataCache self, SoCoordinateElement coords, int32_t const * coordindices, int const numcoordindices, int32_t const * matindices, int32_t const * normindices, int32_t const * texindices, SoConvexDataCache::Binding const matbinding, SoConvexDataCache::Binding const normbinding, SoConvexDataCache::Binding const texbinding)"""
        return _coin.SoConvexDataCache_generate(self, coords, coordindices, numcoordindices, matindices, normindices, texindices, matbinding, normbinding, texbinding)


    def getCoordIndices(self):
        """getCoordIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getCoordIndices(self)


    def getNumCoordIndices(self):
        """getNumCoordIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumCoordIndices(self)


    def getMaterialIndices(self):
        """getMaterialIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getMaterialIndices(self)


    def getNumMaterialIndices(self):
        """getNumMaterialIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumMaterialIndices(self)


    def getNormalIndices(self):
        """getNormalIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getNormalIndices(self)


    def getNumNormalIndices(self):
        """getNumNormalIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumNormalIndices(self)


    def getTexIndices(self):
        """getTexIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getTexIndices(self)


    def getNumTexIndices(self):
        """getNumTexIndices(SoConvexDataCache 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, state):
        """init(SoGLLazyElement self, SoState state)"""
        return _coin.SoGLLazyElement_init(self, state)


    def push(self, state):
        """push(SoGLLazyElement self, SoState state)"""
        return _coin.SoGLLazyElement_push(self, state)


    def pop(self, state, prevtopelement):
        """pop(SoGLLazyElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoGLLazyElement_pop(self, state, prevtopelement)


    def sendAllMaterial(state):
        """sendAllMaterial(SoState state)"""
        return _coin.SoGLLazyElement_sendAllMaterial(state)

    sendAllMaterial = staticmethod(sendAllMaterial)

    def sendNoMaterial(state):
        """sendNoMaterial(SoState state)"""
        return _coin.SoGLLazyElement_sendNoMaterial(state)

    sendNoMaterial = staticmethod(sendNoMaterial)

    def sendOnlyDiffuseColor(state):
        """sendOnlyDiffuseColor(SoState state)"""
        return _coin.SoGLLazyElement_sendOnlyDiffuseColor(state)

    sendOnlyDiffuseColor = staticmethod(sendOnlyDiffuseColor)

    def sendLightModel(state, model):
        """sendLightModel(SoState state, int32_t const model)"""
        return _coin.SoGLLazyElement_sendLightModel(state, model)

    sendLightModel = staticmethod(sendLightModel)

    def sendPackedDiffuse(state, diffuse):
        """sendPackedDiffuse(SoState state, uint32_t const diffuse)"""
        return _coin.SoGLLazyElement_sendPackedDiffuse(state, diffuse)

    sendPackedDiffuse = staticmethod(sendPackedDiffuse)

    def sendFlatshading(state, onoff):
        """sendFlatshading(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendFlatshading(state, onoff)

    sendFlatshading = staticmethod(sendFlatshading)

    def sendVertexOrdering(state, ordering):
        """sendVertexOrdering(SoState state, SoLazyElement::VertexOrdering const ordering)"""
        return _coin.SoGLLazyElement_sendVertexOrdering(state, ordering)

    sendVertexOrdering = staticmethod(sendVertexOrdering)

    def sendTwosideLighting(state, onoff):
        """sendTwosideLighting(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendTwosideLighting(state, onoff)

    sendTwosideLighting = staticmethod(sendTwosideLighting)

    def sendBackfaceCulling(state, onoff):
        """sendBackfaceCulling(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendBackfaceCulling(state, onoff)

    sendBackfaceCulling = staticmethod(sendBackfaceCulling)

    def sendDiffuseByIndex(self, index):
        """sendDiffuseByIndex(SoGLLazyElement self, int const index)"""
        return _coin.SoGLLazyElement_sendDiffuseByIndex(self, index)


    def isColorIndex(state):
        """isColorIndex(SoState state) -> SbBool"""
        return _coin.SoGLLazyElement_isColorIndex(state)

    isColorIndex = staticmethod(isColorIndex)

    def getInstance(state):
        """getInstance(SoState state) -> SoGLLazyElement"""
        return _coin.SoGLLazyElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def send(self, state, mask):
        """send(SoGLLazyElement self, SoState state, uint32_t mask)"""
        return _coin.SoGLLazyElement_send(self, state, mask)


    def sendVPPacked(self, state, pcolor):
        """sendVPPacked(SoGLLazyElement self, SoState state, unsigned char const * pcolor)"""
        return _coin.SoGLLazyElement_sendVPPacked(self, state, pcolor)


    def reset(self, state, bitmask):
        """reset(SoGLLazyElement self, SoState state, uint32_t bitmask)"""
        return _coin.SoGLLazyElement_reset(self, state, bitmask)


    def setDiffuseElt(self, arg2, numcolors, colors, packer):
        """setDiffuseElt(SoGLLazyElement self, SoNode arg2, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
        return _coin.SoGLLazyElement_setDiffuseElt(self, arg2, numcolors, colors, packer)


    def setPackedElt(self, node, numcolors, colors, packedtransparency):
        """setPackedElt(SoGLLazyElement self, SoNode node, int32_t numcolors, uint32_t const * colors, SbBool const packedtransparency)"""
        return _coin.SoGLLazyElement_setPackedElt(self, node, numcolors, colors, packedtransparency)


    def setColorIndexElt(self, node, numindices, indices):
        """setColorIndexElt(SoGLLazyElement self, SoNode node, int32_t numindices, int32_t const * indices)"""
        return _coin.SoGLLazyElement_setColorIndexElt(self, node, numindices, indices)


    def setTranspElt(self, node, numtransp, transp, packer):
        """setTranspElt(SoGLLazyElement self, SoNode node, int32_t numtransp, float const * transp, SoColorPacker packer)"""
        return _coin.SoGLLazyElement_setTranspElt(self, node, numtransp, transp, packer)


    def setTranspTypeElt(self, type):
        """setTranspTypeElt(SoGLLazyElement self, int32_t type)"""
        return _coin.SoGLLazyElement_setTranspTypeElt(self, type)


    def setAmbientElt(self, color):
        """setAmbientElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setAmbientElt(self, color)


    def setEmissiveElt(self, color):
        """setEmissiveElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setEmissiveElt(self, color)


    def setSpecularElt(self, color):
        """setSpecularElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setSpecularElt(self, color)


    def setShininessElt(self, value):
        """setShininessElt(SoGLLazyElement self, float value)"""
        return _coin.SoGLLazyElement_setShininessElt(self, value)


    def setColorMaterialElt(self, value):
        """setColorMaterialElt(SoGLLazyElement self, SbBool value)"""
        return _coin.SoGLLazyElement_setColorMaterialElt(self, value)


    def enableBlendingElt(self, sfactor, dfactor, alpha_sfactor, alpha_dfactor):
        """enableBlendingElt(SoGLLazyElement self, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
        return _coin.SoGLLazyElement_enableBlendingElt(self, sfactor, dfactor, alpha_sfactor, alpha_dfactor)


    def disableBlendingElt(self):
        """disableBlendingElt(SoGLLazyElement self)"""
        return _coin.SoGLLazyElement_disableBlendingElt(self)


    def setLightModelElt(self, state, model):
        """setLightModelElt(SoGLLazyElement self, SoState state, int32_t model)"""
        return _coin.SoGLLazyElement_setLightModelElt(self, state, model)


    def setMaterialElt(self, node, bitmask, packer, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent):
        """setMaterialElt(SoGLLazyElement self, SoNode node, uint32_t bitmask, SoColorPacker packer, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
        return _coin.SoGLLazyElement_setMaterialElt(self, node, bitmask, packer, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)


    def setVertexOrderingElt(self, ordering):
        """setVertexOrderingElt(SoGLLazyElement self, SoLazyElement::VertexOrdering ordering)"""
        return _coin.SoGLLazyElement_setVertexOrderingElt(self, ordering)


    def setBackfaceCullingElt(self, onoff):
        """setBackfaceCullingElt(SoGLLazyElement self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setBackfaceCullingElt(self, onoff)


    def setTwosideLightingElt(self, onoff):
        """setTwosideLightingElt(SoGLLazyElement self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setTwosideLightingElt(self, onoff)


    def setShadeModelElt(self, flatshading):
        """setShadeModelElt(SoGLLazyElement self, SbBool flatshading)"""
        return _coin.SoGLLazyElement_setShadeModelElt(self, flatshading)


    def setGLImageIdElt(self, glimageid, alphatest):
        """setGLImageIdElt(SoGLLazyElement self, uint32_t glimageid, SbBool alphatest)"""
        return _coin.SoGLLazyElement_setGLImageIdElt(self, glimageid, alphatest)


    def setAlphaTestElt(self, onoff):
        """setAlphaTestElt(SoGLLazyElement self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setAlphaTestElt(self, onoff)


    def beginCaching(state, prestate, poststate):
        """beginCaching(SoState state, SoGLLazyElement::GLState * prestate, SoGLLazyElement::GLState * poststate)"""
        return _coin.SoGLLazyElement_beginCaching(state, prestate, poststate)

    beginCaching = staticmethod(beginCaching)

    def endCaching(state):
        """endCaching(SoState state)"""
        return _coin.SoGLLazyElement_endCaching(state)

    endCaching = staticmethod(endCaching)

    def preCacheCall(state, prestate):
        """preCacheCall(SoState state, SoGLLazyElement::GLState * prestate) -> SbBool"""
        return _coin.SoGLLazyElement_preCacheCall(state, prestate)

    preCacheCall = staticmethod(preCacheCall)

    def postCacheCall(state, poststate):
        """postCacheCall(SoState state, SoGLLazyElement::GLState * poststate)"""
        return _coin.SoGLLazyElement_postCacheCall(state, poststate)

    postCacheCall = staticmethod(postCacheCall)

    def mergeCacheInfo(state, childprestate, childpoststate):
        """mergeCacheInfo(SoState state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate)"""
        return _coin.SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate)

    mergeCacheInfo = staticmethod(mergeCacheInfo)

    def updateColorVBO(self, vbo):
        """updateColorVBO(SoGLLazyElement self, SoVBO * vbo)"""
        return _coin.SoGLLazyElement_updateColorVBO(self, vbo)

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(state):
    """SoGLLazyElement_sendAllMaterial(SoState state)"""
    return _coin.SoGLLazyElement_sendAllMaterial(state)

def SoGLLazyElement_sendNoMaterial(state):
    """SoGLLazyElement_sendNoMaterial(SoState state)"""
    return _coin.SoGLLazyElement_sendNoMaterial(state)

def SoGLLazyElement_sendOnlyDiffuseColor(state):
    """SoGLLazyElement_sendOnlyDiffuseColor(SoState state)"""
    return _coin.SoGLLazyElement_sendOnlyDiffuseColor(state)

def SoGLLazyElement_sendLightModel(state, model):
    """SoGLLazyElement_sendLightModel(SoState state, int32_t const model)"""
    return _coin.SoGLLazyElement_sendLightModel(state, model)

def SoGLLazyElement_sendPackedDiffuse(state, diffuse):
    """SoGLLazyElement_sendPackedDiffuse(SoState state, uint32_t const diffuse)"""
    return _coin.SoGLLazyElement_sendPackedDiffuse(state, diffuse)

def SoGLLazyElement_sendFlatshading(state, onoff):
    """SoGLLazyElement_sendFlatshading(SoState state, SbBool const onoff)"""
    return _coin.SoGLLazyElement_sendFlatshading(state, onoff)

def SoGLLazyElement_sendVertexOrdering(state, ordering):
    """SoGLLazyElement_sendVertexOrdering(SoState state, SoLazyElement::VertexOrdering const ordering)"""
    return _coin.SoGLLazyElement_sendVertexOrdering(state, ordering)

def SoGLLazyElement_sendTwosideLighting(state, onoff):
    """SoGLLazyElement_sendTwosideLighting(SoState state, SbBool const onoff)"""
    return _coin.SoGLLazyElement_sendTwosideLighting(state, onoff)

def SoGLLazyElement_sendBackfaceCulling(state, onoff):
    """SoGLLazyElement_sendBackfaceCulling(SoState state, SbBool const onoff)"""
    return _coin.SoGLLazyElement_sendBackfaceCulling(state, onoff)

def SoGLLazyElement_isColorIndex(state):
    """SoGLLazyElement_isColorIndex(SoState state) -> SbBool"""
    return _coin.SoGLLazyElement_isColorIndex(state)

def SoGLLazyElement_getInstance(state):
    """SoGLLazyElement_getInstance(SoState state) -> SoGLLazyElement"""
    return _coin.SoGLLazyElement_getInstance(state)

def SoGLLazyElement_beginCaching(state, prestate, poststate):
    """SoGLLazyElement_beginCaching(SoState state, SoGLLazyElement::GLState * prestate, SoGLLazyElement::GLState * poststate)"""
    return _coin.SoGLLazyElement_beginCaching(state, prestate, poststate)

def SoGLLazyElement_endCaching(state):
    """SoGLLazyElement_endCaching(SoState state)"""
    return _coin.SoGLLazyElement_endCaching(state)

def SoGLLazyElement_preCacheCall(state, prestate):
    """SoGLLazyElement_preCacheCall(SoState state, SoGLLazyElement::GLState * prestate) -> SbBool"""
    return _coin.SoGLLazyElement_preCacheCall(state, prestate)

def SoGLLazyElement_postCacheCall(state, poststate):
    """SoGLLazyElement_postCacheCall(SoState state, SoGLLazyElement::GLState * poststate)"""
    return _coin.SoGLLazyElement_postCacheCall(state, poststate)

def SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate):
    """SoGLLazyElement_mergeCacheInfo(SoState state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate)"""
    return _coin.SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate)

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, state):
        """isValid(SoGLRenderCache self, SoState state) -> SbBool"""
        return _coin.SoGLRenderCache_isValid(self, state)


    def addNestedCache(self, child):
        """addNestedCache(SoGLRenderCache self, SoGLDisplayList child)"""
        return _coin.SoGLRenderCache_addNestedCache(self, child)

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, state):
        """__init__(SoNormalCache self, SoState state) -> SoNormalCache"""
        this = _coin.new_SoNormalCache(state)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoNormalCache
    __del__ = lambda self: None

    def set(self, *args):
        """
        set(SoNormalCache self, int const num, SbVec3f normals)
        set(SoNormalCache self, SoNormalGenerator generator)
        """
        return _coin.SoNormalCache_set(self, *args)


    def getNum(self):
        """getNum(SoNormalCache self) -> int"""
        return _coin.SoNormalCache_getNum(self)


    def getNormals(self):
        """getNormals(SoNormalCache self) -> SbVec3f"""
        return _coin.SoNormalCache_getNormals(self)


    def getNumIndices(self):
        """getNumIndices(SoNormalCache self) -> int"""
        return _coin.SoNormalCache_getNumIndices(self)


    def getIndices(self):
        """getIndices(SoNormalCache self) -> int32_t const *"""
        return _coin.SoNormalCache_getIndices(self)


    def generatePerVertex(self, coords, numcoords, coordindices, numcoordindices, crease_angle, facenormals=None, numfacenormals=-1, ccw=1, tristrip=0):
        """
        generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None, int const numfacenormals=-1, SbBool const ccw=1, SbBool const tristrip=0)
        generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None, int const numfacenormals=-1, SbBool const ccw=1)
        generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None, int const numfacenormals=-1)
        generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None)
        generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle)
        """
        return _coin.SoNormalCache_generatePerVertex(self, coords, numcoords, coordindices, numcoordindices, crease_angle, facenormals, numfacenormals, ccw, tristrip)


    def generatePerFace(self, coords, numcoords, coordindices, numcoorindices, ccw):
        """generatePerFace(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerFace(self, coords, numcoords, coordindices, numcoorindices, ccw)


    def generatePerFaceStrip(self, coords, numcoords, coordindices, numcoorindices, ccw):
        """generatePerFaceStrip(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerFaceStrip(self, coords, numcoords, coordindices, numcoorindices, ccw)


    def generatePerStrip(self, coords, numcoords, coordindices, numcoorindices, ccw):
        """generatePerStrip(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerStrip(self, coords, numcoords, coordindices, numcoorindices, ccw)


    def generatePerVertexQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw):
        """generatePerVertexQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerVertexQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)


    def generatePerFaceQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw):
        """generatePerFaceQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerFaceQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)


    def generatePerRowQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw):
        """generatePerRowQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
        return _coin.SoNormalCache_generatePerRowQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)

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, state):
        """__init__(SoTextureCoordinateCache self, SoState state) -> SoTextureCoordinateCache"""
        this = _coin.new_SoTextureCoordinateCache(state)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoTextureCoordinateCache
    __del__ = lambda self: None

    def generate(self, bbox, vertices, numvertices):
        """generate(SoTextureCoordinateCache self, SbBox3f bbox, SbVec3f vertices, int const numvertices)"""
        return _coin.SoTextureCoordinateCache_generate(self, bbox, vertices, numvertices)


    def get(self):
        """get(SoTextureCoordinateCache self) -> SbVec2f"""
        return _coin.SoTextureCoordinateCache_get(self)


    def getNum(self):
        """getNum(SoTextureCoordinateCache 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(SoDetail self) -> SoDetail"""
        return _coin.SoDetail_copy(self)


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


    def isOfType(self, type):
        """isOfType(SoDetail self, SoType type) -> SbBool"""
        return _coin.SoDetail_isOfType(self, type)


    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(SoConeDetail 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__(SoConeDetail 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(SoConeDetail self) -> SoDetail"""
        return _coin.SoConeDetail_copy(self)


    def setPart(self, part):
        """setPart(SoConeDetail self, int const part)"""
        return _coin.SoConeDetail_setPart(self, part)


    def getPart(self):
        """getPart(SoConeDetail 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(SoCubeDetail 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__(SoCubeDetail 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(SoCubeDetail self) -> SoDetail"""
        return _coin.SoCubeDetail_copy(self)


    def setPart(self, part):
        """setPart(SoCubeDetail self, int const part)"""
        return _coin.SoCubeDetail_setPart(self, part)


    def getPart(self):
        """getPart(SoCubeDetail 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(SoCylinderDetail 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__(SoCylinderDetail 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(SoCylinderDetail self) -> SoDetail"""
        return _coin.SoCylinderDetail_copy(self)


    def setPart(self, part):
        """setPart(SoCylinderDetail self, int const part)"""
        return _coin.SoCylinderDetail_setPart(self, part)


    def getPart(self):
        """getPart(SoCylinderDetail 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(SoPointDetail 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__(SoPointDetail 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(SoPointDetail self) -> SoDetail"""
        return _coin.SoPointDetail_copy(self)


    def getCoordinateIndex(self):
        """getCoordinateIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getCoordinateIndex(self)


    def getMaterialIndex(self):
        """getMaterialIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getMaterialIndex(self)


    def getNormalIndex(self):
        """getNormalIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getNormalIndex(self)


    def getTextureCoordIndex(self):
        """getTextureCoordIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getTextureCoordIndex(self)


    def setCoordinateIndex(self, idx):
        """setCoordinateIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setCoordinateIndex(self, idx)


    def setMaterialIndex(self, idx):
        """setMaterialIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setMaterialIndex(self, idx)


    def setNormalIndex(self, idx):
        """setNormalIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setNormalIndex(self, idx)


    def setTextureCoordIndex(self, idx):
        """setTextureCoordIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setTextureCoordIndex(self, idx)

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(SoFaceDetail 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__(SoFaceDetail 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(SoFaceDetail self) -> SoDetail"""
        return _coin.SoFaceDetail_copy(self)


    def getNumPoints(self):
        """getNumPoints(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getNumPoints(self)


    def getPoint(self, idx):
        """getPoint(SoFaceDetail self, int const idx) -> SoPointDetail"""
        return _coin.SoFaceDetail_getPoint(self, idx)


    def getPoints(self):
        """getPoints(SoFaceDetail self) -> SoPointDetail"""
        return _coin.SoFaceDetail_getPoints(self)


    def getFaceIndex(self):
        """getFaceIndex(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getFaceIndex(self)


    def getPartIndex(self):
        """getPartIndex(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getPartIndex(self)


    def setNumPoints(self, num):
        """setNumPoints(SoFaceDetail self, int const num)"""
        return _coin.SoFaceDetail_setNumPoints(self, num)


    def setPoint(self, idx, detail):
        """setPoint(SoFaceDetail self, int const idx, SoPointDetail detail)"""
        return _coin.SoFaceDetail_setPoint(self, idx, detail)


    def setFaceIndex(self, idx):
        """setFaceIndex(SoFaceDetail self, int const idx)"""
        return _coin.SoFaceDetail_setFaceIndex(self, idx)


    def setPartIndex(self, idx):
        """setPartIndex(SoFaceDetail self, int const idx)"""
        return _coin.SoFaceDetail_setPartIndex(self, idx)


    def incFaceIndex(self):
        """incFaceIndex(SoFaceDetail self)"""
        return _coin.SoFaceDetail_incFaceIndex(self)


    def incPartIndex(self):
        """incPartIndex(SoFaceDetail 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(SoLineDetail 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__(SoLineDetail 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(SoLineDetail self) -> SoDetail"""
        return _coin.SoLineDetail_copy(self)


    def getPoint0(self):
        """getPoint0(SoLineDetail self) -> SoPointDetail"""
        return _coin.SoLineDetail_getPoint0(self)


    def getPoint1(self):
        """getPoint1(SoLineDetail self) -> SoPointDetail"""
        return _coin.SoLineDetail_getPoint1(self)


    def getLineIndex(self):
        """getLineIndex(SoLineDetail self) -> int"""
        return _coin.SoLineDetail_getLineIndex(self)


    def getPartIndex(self):
        """getPartIndex(SoLineDetail self) -> int"""
        return _coin.SoLineDetail_getPartIndex(self)


    def setPoint0(self, detail):
        """setPoint0(SoLineDetail self, SoPointDetail detail)"""
        return _coin.SoLineDetail_setPoint0(self, detail)


    def setPoint1(self, detail):
        """setPoint1(SoLineDetail self, SoPointDetail detail)"""
        return _coin.SoLineDetail_setPoint1(self, detail)


    def setLineIndex(self, idx):
        """setLineIndex(SoLineDetail self, int const idx)"""
        return _coin.SoLineDetail_setLineIndex(self, idx)


    def setPartIndex(self, idx):
        """setPartIndex(SoLineDetail self, int const idx)"""
        return _coin.SoLineDetail_setPartIndex(self, idx)


    def incLineIndex(self):
        """incLineIndex(SoLineDetail self)"""
        return _coin.SoLineDetail_incLineIndex(self)


    def incPartIndex(self):
        """incPartIndex(SoLineDetail 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(SoNodeKitDetail 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__(SoNodeKitDetail 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(SoNodeKitDetail self) -> SoDetail"""
        return _coin.SoNodeKitDetail_copy(self)


    def setNodeKit(self, kit):
        """setNodeKit(SoNodeKitDetail self, SoBaseKit kit)"""
        return _coin.SoNodeKitDetail_setNodeKit(self, kit)


    def getNodeKit(self):
        """getNodeKit(SoNodeKitDetail self) -> SoBaseKit"""
        return _coin.SoNodeKitDetail_getNodeKit(self)


    def setPart(self, part):
        """setPart(SoNodeKitDetail self, SoNode part)"""
        return _coin.SoNodeKitDetail_setPart(self, part)


    def getPart(self):
        """getPart(SoNodeKitDetail self) -> SoNode"""
        return _coin.SoNodeKitDetail_getPart(self)


    def setPartName(self, name):
        """setPartName(SoNodeKitDetail self, SbName name)"""
        return _coin.SoNodeKitDetail_setPartName(self, name)


    def getPartName(self):
        """getPartName(SoNodeKitDetail 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(SoTextDetail 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__(SoTextDetail 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(SoTextDetail self) -> SoDetail"""
        return _coin.SoTextDetail_copy(self)


    def getStringIndex(self):
        """getStringIndex(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getStringIndex(self)


    def getCharacterIndex(self):
        """getCharacterIndex(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getCharacterIndex(self)


    def getPart(self):
        """getPart(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getPart(self)


    def setStringIndex(self, idx):
        """setStringIndex(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setStringIndex(self, idx)


    def setCharacterIndex(self, idx):
        """setCharacterIndex(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setCharacterIndex(self, idx)


    def setPart(self, idx):
        """setPart(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setPart(self, idx)

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__(SoSFNode 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(SoSFNode self) -> SoType"""
        return _coin.SoSFNode_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFNode self, SoField field)"""
        return _coin.SoSFNode_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFNode self, SoField field) -> SbBool"""
        return _coin.SoSFNode_isSame(self, field)


    def getValue(self):
        """getValue(SoSFNode self) -> SoNode"""
        return _coin.SoSFNode_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFNode self, SoSFNode field) -> int"""
        return _coin.SoSFNode___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFNode self, SoSFNode field) -> int"""
        return _coin.SoSFNode___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def fixCopy(self, copyconnections):
        """fixCopy(SoSFNode self, SbBool copyconnections)"""
        return _coin.SoSFNode_fixCopy(self, copyconnections)


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


    def setValue(self, *args):
        """
        setValue(SoSFNode self, SoNode newvalue)
        setValue(SoSFNode 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()


_coin.SO_CATALOG_NAME_NOT_FOUND_swigconstant(_coin)
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__(SoNodekitCatalog 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(SoNodekitCatalog self) -> int"""
        return _coin.SoNodekitCatalog_getNumEntries(self)


    def getPartNumber(self, name):
        """getPartNumber(SoNodekitCatalog self, SbName name) -> int"""
        return _coin.SoNodekitCatalog_getPartNumber(self, name)


    def getName(self, part):
        """getName(SoNodekitCatalog self, int part) -> SbName"""
        return _coin.SoNodekitCatalog_getName(self, part)


    def getType(self, *args):
        """
        getType(SoNodekitCatalog self, int part) -> SoType
        getType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getType(self, *args)


    def getDefaultType(self, *args):
        """
        getDefaultType(SoNodekitCatalog self, int part) -> SoType
        getDefaultType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getDefaultType(self, *args)


    def isNullByDefault(self, *args):
        """
        isNullByDefault(SoNodekitCatalog self, int part) -> SbBool
        isNullByDefault(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isNullByDefault(self, *args)


    def isLeaf(self, *args):
        """
        isLeaf(SoNodekitCatalog self, int part) -> SbBool
        isLeaf(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isLeaf(self, *args)


    def getParentName(self, *args):
        """
        getParentName(SoNodekitCatalog self, int part) -> SbName
        getParentName(SoNodekitCatalog self, SbName name) -> SbName
        """
        return _coin.SoNodekitCatalog_getParentName(self, *args)


    def getParentPartNumber(self, *args):
        """
        getParentPartNumber(SoNodekitCatalog self, int part) -> int
        getParentPartNumber(SoNodekitCatalog self, SbName name) -> int
        """
        return _coin.SoNodekitCatalog_getParentPartNumber(self, *args)


    def getRightSiblingName(self, *args):
        """
        getRightSiblingName(SoNodekitCatalog self, int part) -> SbName
        getRightSiblingName(SoNodekitCatalog self, SbName name) -> SbName
        """
        return _coin.SoNodekitCatalog_getRightSiblingName(self, *args)


    def getRightSiblingPartNumber(self, *args):
        """
        getRightSiblingPartNumber(SoNodekitCatalog self, int part) -> int
        getRightSiblingPartNumber(SoNodekitCatalog self, SbName name) -> int
        """
        return _coin.SoNodekitCatalog_getRightSiblingPartNumber(self, *args)


    def isList(self, *args):
        """
        isList(SoNodekitCatalog self, int part) -> SbBool
        isList(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isList(self, *args)


    def getListContainerType(self, *args):
        """
        getListContainerType(SoNodekitCatalog self, int part) -> SoType
        getListContainerType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getListContainerType(self, *args)


    def getListItemTypes(self, *args):
        """
        getListItemTypes(SoNodekitCatalog self, int part) -> SoTypeList
        getListItemTypes(SoNodekitCatalog self, SbName name) -> SoTypeList
        """
        return _coin.SoNodekitCatalog_getListItemTypes(self, *args)


    def isPublic(self, *args):
        """
        isPublic(SoNodekitCatalog self, int part) -> SbBool
        isPublic(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isPublic(self, *args)


    def clone(self, type):
        """clone(SoNodekitCatalog self, SoType type) -> SoNodekitCatalog"""
        return _coin.SoNodekitCatalog_clone(self, type)


    def addEntry(self, name, type, defaulttype, isdefaultnull, parent, rightsibling, islist, listcontainertype, listitemtype, ispublic):
        """addEntry(SoNodekitCatalog 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, name, type, defaulttype, isdefaultnull, parent, rightsibling, islist, listcontainertype, listitemtype, ispublic)


    def addListItemType(self, *args):
        """
        addListItemType(SoNodekitCatalog self, int part, SoType type)
        addListItemType(SoNodekitCatalog self, SbName name, SoType type)
        """
        return _coin.SoNodekitCatalog_addListItemType(self, *args)


    def narrowTypes(self, name, newtype, newdefaulttype):
        """narrowTypes(SoNodekitCatalog self, SbName name, SoType newtype, SoType newdefaulttype)"""
        return _coin.SoNodekitCatalog_narrowTypes(self, name, newtype, newdefaulttype)


    def setNullByDefault(self, name, nullbydefault):
        """setNullByDefault(SoNodekitCatalog self, SbName name, SbBool nullbydefault)"""
        return _coin.SoNodekitCatalog_setNullByDefault(self, name, nullbydefault)


    def recursiveSearch(self, part, name, checked):
        """recursiveSearch(SoNodekitCatalog self, int part, SbName name, SoTypeList checked) -> SbBool"""
        return _coin.SoNodekitCatalog_recursiveSearch(self, part, name, checked)


    def printCheck(self):
        """printCheck(SoNodekitCatalog 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__(SoSFName 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(SoSFName self) -> SoType"""
        return _coin.SoSFName_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFName self, SoField field)"""
        return _coin.SoSFName_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFName self, SoField field) -> SbBool"""
        return _coin.SoSFName_isSame(self, field)


    def getValue(self):
        """getValue(SoSFName self) -> SbName"""
        return _coin.SoSFName_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFName self, SoSFName field) -> int"""
        return _coin.SoSFName___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFName self, SoSFName field) -> int"""
        return _coin.SoSFName___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFName self, SbName newvalue)
        setValue(SoSFName self, char const *const name)
        setValue(SoSFName 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__(SoMFName 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(SoMFName self) -> SoType"""
        return _coin.SoMFName_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFName self, SoField field)"""
        return _coin.SoMFName_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFName self, SoField field) -> SbBool"""
        return _coin.SoMFName_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFName self, SbName value, SbBool addifnotfound=0) -> int
        find(SoMFName self, SbName value) -> int
        """
        return _coin.SoMFName_find(self, value, addifnotfound)


    def set1Value(self, idx, value):
        """set1Value(SoMFName self, int const idx, SbName value)"""
        return _coin.SoMFName_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFName self, SoMFName field) -> SbBool"""
        return _coin.SoMFName___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFName self, SoMFName field) -> SbBool"""
        return _coin.SoMFName___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFName self) -> SbName"""
        return _coin.SoMFName_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFName 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, i):
        """__getitem__(SoMFName self, int i) -> SbName"""
        return _coin.SoMFName___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFName self, int i, SbName value)"""
        return _coin.SoMFName___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFName self, SbName value)
        setValue(SoMFName self, char const * str)
        setValue(SoMFName self, SoMFName other)
        """
        return _coin.SoMFName_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFName self, int i=0) -> SbName
        getValues(SoMFName 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(SoNodeKitListPart self) -> SoType"""
        return _coin.SoNodeKitListPart_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoNodeKitListPart self) -> SoNodeKitListPart"""
        this = _coin.new_SoNodeKitListPart()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getContainerType(self):
        """getContainerType(SoNodeKitListPart self) -> SoType"""
        return _coin.SoNodeKitListPart_getContainerType(self)


    def setContainerType(self, newContainerType):
        """setContainerType(SoNodeKitListPart self, SoType newContainerType)"""
        return _coin.SoNodeKitListPart_setContainerType(self, newContainerType)


    def getChildTypes(self):
        """getChildTypes(SoNodeKitListPart self) -> SoTypeList"""
        return _coin.SoNodeKitListPart_getChildTypes(self)


    def addChildType(self, typeToAdd):
        """addChildType(SoNodeKitListPart self, SoType typeToAdd)"""
        return _coin.SoNodeKitListPart_addChildType(self, typeToAdd)


    def isTypePermitted(self, typeToCheck):
        """isTypePermitted(SoNodeKitListPart self, SoType typeToCheck) -> SbBool"""
        return _coin.SoNodeKitListPart_isTypePermitted(self, typeToCheck)


    def isChildPermitted(self, child):
        """isChildPermitted(SoNodeKitListPart self, SoNode child) -> SbBool"""
        return _coin.SoNodeKitListPart_isChildPermitted(self, child)


    def containerSet(self, fieldDataString):
        """containerSet(SoNodeKitListPart self, char const * fieldDataString)"""
        return _coin.SoNodeKitListPart_containerSet(self, fieldDataString)


    def lockTypes(self):
        """lockTypes(SoNodeKitListPart self)"""
        return _coin.SoNodeKitListPart_lockTypes(self)


    def isTypeLocked(self):
        """isTypeLocked(SoNodeKitListPart self) -> SbBool"""
        return _coin.SoNodeKitListPart_isTypeLocked(self)


    def addChild(self, child):
        """addChild(SoNodeKitListPart self, SoNode child)"""
        return _coin.SoNodeKitListPart_addChild(self, child)


    def insertChild(self, child, childIndex):
        """insertChild(SoNodeKitListPart self, SoNode child, int childIndex)"""
        return _coin.SoNodeKitListPart_insertChild(self, child, childIndex)


    def getChild(self, index):
        """getChild(SoNodeKitListPart self, int index) -> SoNode"""
        return _coin.SoNodeKitListPart_getChild(self, index)


    def findChild(self, child):
        """findChild(SoNodeKitListPart self, SoNode child) -> int"""
        return _coin.SoNodeKitListPart_findChild(self, child)


    def getNumChildren(self):
        """getNumChildren(SoNodeKitListPart self) -> int"""
        return _coin.SoNodeKitListPart_getNumChildren(self)


    def removeChild(self, *args):
        """
        removeChild(SoNodeKitListPart self, int index)
        removeChild(SoNodeKitListPart self, SoNode child)
        """
        return _coin.SoNodeKitListPart_removeChild(self, *args)


    def replaceChild(self, *args):
        """
        replaceChild(SoNodeKitListPart self, int index, SoNode newChild)
        replaceChild(SoNodeKitListPart self, SoNode oldChild, SoNode newChild)
        """
        return _coin.SoNodeKitListPart_replaceChild(self, *args)


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


    def doAction(self, action):
        """doAction(SoNodeKitListPart self, SoAction action)"""
        return _coin.SoNodeKitListPart_doAction(self, action)


    def callback(self, action):
        """callback(SoNodeKitListPart self, SoCallbackAction action)"""
        return _coin.SoNodeKitListPart_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoNodeKitListPart self, SoGLRenderAction action)"""
        return _coin.SoNodeKitListPart_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoNodeKitListPart self, SoGetBoundingBoxAction action)"""
        return _coin.SoNodeKitListPart_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoNodeKitListPart self, SoGetMatrixAction action)"""
        return _coin.SoNodeKitListPart_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoNodeKitListPart self, SoHandleEventAction action)"""
        return _coin.SoNodeKitListPart_handleEvent(self, action)


    def pick(self, action):
        """pick(SoNodeKitListPart self, SoPickAction action)"""
        return _coin.SoNodeKitListPart_pick(self, action)


    def search(self, action):
        """search(SoNodeKitListPart self, SoSearchAction action)"""
        return _coin.SoNodeKitListPart_search(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoNodeKitListPart self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNodeKitListPart_getPrimitiveCount(self, action)


    def getChildren(self):
        """getChildren(SoNodeKitListPart 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(SoNodeKitPath self) -> int"""
        return _coin.SoNodeKitPath_getLength(self)


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


    def getNode(self, idx):
        """getNode(SoNodeKitPath self, int const idx) -> SoNode"""
        return _coin.SoNodeKitPath_getNode(self, idx)


    def getNodeFromTail(self, idx):
        """getNodeFromTail(SoNodeKitPath self, int const idx) -> SoNode"""
        return _coin.SoNodeKitPath_getNodeFromTail(self, idx)


    def truncate(self, length):
        """truncate(SoNodeKitPath self, int const length)"""
        return _coin.SoNodeKitPath_truncate(self, length)


    def pop(self):
        """pop(SoNodeKitPath self)"""
        return _coin.SoNodeKitPath_pop(self)


    def append(self, *args):
        """
        append(SoNodeKitPath self, SoBaseKit childKit)
        append(SoNodeKitPath self, SoNodeKitPath fromPath)
        """
        return _coin.SoNodeKitPath_append(self, *args)


    def containsNode(self, node):
        """containsNode(SoNodeKitPath self, SoBaseKit node) -> SbBool"""
        return _coin.SoNodeKitPath_containsNode(self, node)


    def findFork(self, path):
        """findFork(SoNodeKitPath self, SoNodeKitPath path) -> int"""
        return _coin.SoNodeKitPath_findFork(self, path)


    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, u):
        """__eq__(SoNodeKitPath self, SoNodeKitPath u) -> int"""
        return _coin.SoNodeKitPath___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SoNodeKitPath self, SoNodeKitPath u) -> int"""
        return _coin.SoNodeKitPath___nq__(self, u)

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__(SoChildList self, SoNode parent) -> SoChildList
        __init__(SoChildList self, SoNode parent, int const size) -> SoChildList
        __init__(SoChildList 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, node):
        """append(SoChildList self, SoNode node)"""
        return _coin.SoChildList_append(self, node)


    def insert(self, ptr, addbefore):
        """insert(SoChildList self, SoNode ptr, int const addbefore)"""
        return _coin.SoChildList_insert(self, ptr, addbefore)


    def remove(self, index):
        """remove(SoChildList self, int const index)"""
        return _coin.SoChildList_remove(self, index)


    def truncate(self, length):
        """truncate(SoChildList self, int const length)"""
        return _coin.SoChildList_truncate(self, length)


    def copy(self, cl):
        """copy(SoChildList self, SoChildList cl)"""
        return _coin.SoChildList_copy(self, cl)


    def set(self, index, node):
        """set(SoChildList self, int const index, SoNode node)"""
        return _coin.SoChildList_set(self, index, node)


    def traverseInPath(self, action, numindices, indices):
        """traverseInPath(SoChildList self, SoAction action, int const numindices, int const * indices)"""
        return _coin.SoChildList_traverseInPath(self, action, numindices, indices)


    def traverse(self, *args):
        """
        traverse(SoChildList self, SoAction action)
        traverse(SoChildList self, SoAction action, int const index)
        traverse(SoChildList self, SoAction action, SoNode node)
        traverse(SoChildList self, SoAction action, int const first, int const last)
        """
        return _coin.SoChildList_traverse(self, *args)


    def addPathAuditor(self, path):
        """addPathAuditor(SoChildList self, SoPath path)"""
        return _coin.SoChildList_addPathAuditor(self, path)


    def removePathAuditor(self, path):
        """removePathAuditor(SoChildList self, SoPath path)"""
        return _coin.SoChildList_removePathAuditor(self, path)

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(SoBaseKit self) -> SoType"""
        return _coin.SoBaseKit_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoBaseKit 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(SoBaseKit self) -> SoNodekitCatalog"""
        return _coin.SoBaseKit_getNodekitCatalog(self)


    def getPart(self, partname, makeifneeded):
        """getPart(SoBaseKit self, SbName partname, SbBool makeifneeded) -> SoNode"""
        return _coin.SoBaseKit_getPart(self, partname, makeifneeded)


    def getPartString(self, part):
        """getPartString(SoBaseKit self, SoBase part) -> SbString"""
        return _coin.SoBaseKit_getPartString(self, part)


    def createPathToPart(self, partname, makeifneeded, pathtoextend=None):
        """
        createPathToPart(SoBaseKit self, SbName partname, SbBool makeifneeded, SoPath pathtoextend=None) -> SoNodeKitPath
        createPathToPart(SoBaseKit self, SbName partname, SbBool makeifneeded) -> SoNodeKitPath
        """
        return _coin.SoBaseKit_createPathToPart(self, partname, makeifneeded, pathtoextend)


    def setPart(self, partname, arg3):
        """setPart(SoBaseKit self, SbName partname, SoNode arg3) -> SbBool"""
        return _coin.SoBaseKit_setPart(self, partname, arg3)


    def set(self, *args):
        """
        set(SoBaseKit self, char const * namevaluepairliststring) -> SbBool
        set(SoBaseKit self, char const * partnamestring, char const * parameterstring) -> SbBool
        """
        return _coin.SoBaseKit_set(self, *args)


    def doAction(self, action):
        """doAction(SoBaseKit self, SoAction action)"""
        return _coin.SoBaseKit_doAction(self, action)


    def callback(self, action):
        """callback(SoBaseKit self, SoCallbackAction action)"""
        return _coin.SoBaseKit_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoBaseKit self, SoGLRenderAction action)"""
        return _coin.SoBaseKit_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoBaseKit self, SoGetBoundingBoxAction action)"""
        return _coin.SoBaseKit_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoBaseKit self, SoGetMatrixAction action)"""
        return _coin.SoBaseKit_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoBaseKit self, SoHandleEventAction action)"""
        return _coin.SoBaseKit_handleEvent(self, action)


    def rayPick(self, action):
        """rayPick(SoBaseKit self, SoRayPickAction action)"""
        return _coin.SoBaseKit_rayPick(self, action)


    def search(self, action):
        """search(SoBaseKit self, SoSearchAction action)"""
        return _coin.SoBaseKit_search(self, action)


    def write(self, action):
        """write(SoBaseKit self, SoWriteAction action)"""
        return _coin.SoBaseKit_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoBaseKit self, SoGetPrimitiveCountAction action)"""
        return _coin.SoBaseKit_getPrimitiveCount(self, action)


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


    def printDiagram(self):
        """printDiagram(SoBaseKit self)"""
        return _coin.SoBaseKit_printDiagram(self)


    def printSubDiagram(self, rootname, level):
        """printSubDiagram(SoBaseKit self, SbName rootname, int level)"""
        return _coin.SoBaseKit_printSubDiagram(self, rootname, level)


    def printTable(self):
        """printTable(SoBaseKit self)"""
        return _coin.SoBaseKit_printTable(self)


    def addWriteReference(self, out, isfromfield=0):
        """
        addWriteReference(SoBaseKit self, SoOutput out, SbBool isfromfield=0)
        addWriteReference(SoBaseKit self, SoOutput out)
        """
        return _coin.SoBaseKit_addWriteReference(self, out, isfromfield)


    def forceChildDrivenWriteRefs(self, out):
        """forceChildDrivenWriteRefs(SoBaseKit self, SoOutput out) -> SbBool"""
        return _coin.SoBaseKit_forceChildDrivenWriteRefs(self, out)


    def isSearchingChildren():
        """isSearchingChildren() -> SbBool"""
        return _coin.SoBaseKit_isSearchingChildren()

    isSearchingChildren = staticmethod(isSearchingChildren)

    def setSearchingChildren(newval):
        """setSearchingChildren(SbBool const newval)"""
        return _coin.SoBaseKit_setSearchingChildren(newval)

    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(newval):
    """SoBaseKit_setSearchingChildren(SbBool const newval)"""
    return _coin.SoBaseKit_setSearchingChildren(newval)

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, callbackfunction):
        """setFunction(SoSensor self, SoSensorCB * callbackfunction)"""
        return _coin.SoSensor_setFunction(self, callbackfunction)


    def getFunction(self):
        """getFunction(SoSensor self) -> SoSensorCBPtr"""
        return _coin.SoSensor_getFunction(self)


    def setData(self, callbackdata):
        """setData(SoSensor self, void * callbackdata)"""
        return _coin.SoSensor_setData(self, callbackdata)


    def getData(self):
        """getData(SoSensor self) -> void *"""
        return _coin.SoSensor_getData(self)


    def schedule(self):
        """schedule(SoSensor self)"""
        return _coin.SoSensor_schedule(self)


    def unschedule(self):
        """unschedule(SoSensor self)"""
        return _coin.SoSensor_unschedule(self)


    def isScheduled(self):
        """isScheduled(SoSensor self) -> SbBool"""
        return _coin.SoSensor_isScheduled(self)


    def trigger(self):
        """trigger(SoSensor self)"""
        return _coin.SoSensor_trigger(self)


    def isBefore(self, s):
        """isBefore(SoSensor self, SoSensor s) -> SbBool"""
        return _coin.SoSensor_isBefore(self, s)


    def setNextInQueue(self, next):
        """setNextInQueue(SoSensor self, SoSensor next)"""
        return _coin.SoSensor_setNextInQueue(self, next)


    def getNextInQueue(self):
        """getNextInQueue(SoSensor 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, pri):
        """setPriority(SoDelayQueueSensor self, uint32_t pri)"""
        return _coin.SoDelayQueueSensor_setPriority(self, pri)


    def getPriority(self):
        """getPriority(SoDelayQueueSensor self) -> uint32_t"""
        return _coin.SoDelayQueueSensor_getPriority(self)


    def getDefaultPriority():
        """getDefaultPriority() -> uint32_t"""
        return _coin.SoDelayQueueSensor_getDefaultPriority()

    getDefaultPriority = staticmethod(getDefaultPriority)

    def schedule(self):
        """schedule(SoDelayQueueSensor self)"""
        return _coin.SoDelayQueueSensor_schedule(self)


    def unschedule(self):
        """unschedule(SoDelayQueueSensor self)"""
        return _coin.SoDelayQueueSensor_unschedule(self)


    def isScheduled(self):
        """isScheduled(SoDelayQueueSensor self) -> SbBool"""
        return _coin.SoDelayQueueSensor_isScheduled(self)


    def isIdleOnly(self):
        """isIdleOnly(SoDelayQueueSensor self) -> SbBool"""
        return _coin.SoDelayQueueSensor_isIdleOnly(self)


    def trigger(self):
        """trigger(SoDelayQueueSensor 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, function, data=None):
        """
        setDeleteCallback(SoDataSensor self, SoSensorCB * function, void * data=None)
        setDeleteCallback(SoDataSensor self, SoSensorCB * function)
        """
        return _coin.SoDataSensor_setDeleteCallback(self, function, data)


    def getTriggerNode(self):
        """getTriggerNode(SoDataSensor self) -> SoNode"""
        return _coin.SoDataSensor_getTriggerNode(self)


    def getTriggerField(self):
        """getTriggerField(SoDataSensor self) -> SoField"""
        return _coin.SoDataSensor_getTriggerField(self)


    def getTriggerPath(self):
        """getTriggerPath(SoDataSensor self) -> SoPath"""
        return _coin.SoDataSensor_getTriggerPath(self)


    def setTriggerPathFlag(self, flag):
        """setTriggerPathFlag(SoDataSensor self, SbBool flag)"""
        return _coin.SoDataSensor_setTriggerPathFlag(self, flag)


    def getTriggerPathFlag(self):
        """getTriggerPathFlag(SoDataSensor self) -> SbBool"""
        return _coin.SoDataSensor_getTriggerPathFlag(self)


    def trigger(self):
        """trigger(SoDataSensor self)"""
        return _coin.SoDataSensor_trigger(self)


    def notify(self, l):
        """notify(SoDataSensor self, SoNotList l)"""
        return _coin.SoDataSensor_notify(self, l)


    def dyingReference(self):
        """dyingReference(SoDataSensor 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, field):
        """attach(SoFieldSensor self, SoField field)"""
        return _coin.SoFieldSensor_attach(self, field)


    def detach(self):
        """detach(SoFieldSensor self)"""
        return _coin.SoFieldSensor_detach(self)


    def getAttachedField(self):
        """getAttachedField(SoFieldSensor self) -> SoField"""
        return _coin.SoFieldSensor_getAttachedField(self)


    def trigger(self):
        """trigger(SoFieldSensor 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(SoInteractionKit self) -> SoType"""
        return _coin.SoInteractionKit_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoInteractionKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoInteractionKit 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__(SoInteractionKit 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, partname, path):
        """setPartAsPath(SoInteractionKit self, SbName partname, SoPath path) -> SbBool"""
        return _coin.SoInteractionKit_setPartAsPath(self, partname, path)


    def setPartAsDefault(self, *args):
        """
        setPartAsDefault(SoInteractionKit self, SbName partname, SoNode node, SbBool onlyifdefault=1) -> SbBool
        setPartAsDefault(SoInteractionKit self, SbName partname, SoNode node) -> SbBool
        setPartAsDefault(SoInteractionKit self, SbName partname, SbName nodename, SbBool onlyifdefault=1) -> SbBool
        setPartAsDefault(SoInteractionKit self, SbName partname, SbName nodename) -> SbBool
        """
        return _coin.SoInteractionKit_setPartAsDefault(self, *args)


    def isPathSurrogateInMySubgraph(self, *args):
        """
        isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path, SoPath *& pathToOwner, SbName surrogatename, SoPath *& surrogatepath, SbBool fillargs=1) -> SbBool
        isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path, SoPath *& pathToOwner, SbName surrogatename, SoPath *& surrogatepath) -> SbBool
        isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path) -> SbBool
        """
        return _coin.SoInteractionKit_isPathSurrogateInMySubgraph(self, *args)


    def setSwitchValue(node, newVal):
        """setSwitchValue(SoNode node, int const newVal)"""
        return _coin.SoInteractionKit_setSwitchValue(node, newVal)

    setSwitchValue = staticmethod(setSwitchValue)

    def setPart(self, partname, arg3):
        """setPart(SoInteractionKit self, SbName partname, SoNode arg3) -> SbBool"""
        return _coin.SoInteractionKit_setPart(self, partname, arg3)

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(node, newVal):
    """SoInteractionKit_setSwitchValue(SoNode node, int const newVal)"""
    return _coin.SoInteractionKit_setSwitchValue(node, newVal)

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__(SoCallbackList 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, f, userData=None):
        """
        addCallback(SoCallbackList self, SoCallbackListCB * f, void * userData=None)
        addCallback(SoCallbackList self, SoCallbackListCB * f)
        """
        return _coin.SoCallbackList_addCallback(self, f, userData)


    def removeCallback(self, f, userdata=None):
        """
        removeCallback(SoCallbackList self, SoCallbackListCB * f, void * userdata=None)
        removeCallback(SoCallbackList self, SoCallbackListCB * f)
        """
        return _coin.SoCallbackList_removeCallback(self, f, userdata)


    def clearCallbacks(self):
        """clearCallbacks(SoCallbackList self)"""
        return _coin.SoCallbackList_clearCallbacks(self)


    def getNumCallbacks(self):
        """getNumCallbacks(SoCallbackList self) -> int"""
        return _coin.SoCallbackList_getNumCallbacks(self)


    def invokeCallbacks(self, callbackdata):
        """invokeCallbacks(SoCallbackList self, void * callbackdata)"""
        return _coin.SoCallbackList_invokeCallbacks(self, callbackdata)

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__(SbVec3d self) -> SbVec3d
        __init__(SbVec3d self, double const [3] v) -> SbVec3d
        __init__(SbVec3d self, double x, double y, double z) -> SbVec3d
        __init__(SbVec3d self, SbVec3f v) -> SbVec3d
        __init__(SbVec3d self, SbVec3b v) -> SbVec3d
        __init__(SbVec3d self, SbVec3s v) -> SbVec3d
        __init__(SbVec3d self, SbVec3i32 v) -> SbVec3d
        __init__(SbVec3d 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(SbVec3d self, double const [3] v) -> SbVec3d
        setValue(SbVec3d self, double x, double y, double z) -> SbVec3d
        setValue(SbVec3d self, SbVec3d barycentric, SbVec3d v0, SbVec3d v1, SbVec3d v2) -> SbVec3d
        setValue(SbVec3d self, SbVec3f v) -> SbVec3d
        setValue(SbVec3d self, SbVec3b v) -> SbVec3d
        setValue(SbVec3d self, SbVec3s v) -> SbVec3d
        setValue(SbVec3d self, SbVec3i32 v) -> SbVec3d
        """
        return _coin.SbVec3d_setValue(self, *args)


    def getValue(self):
        """getValue(SbVec3d self) -> double const *"""
        return _coin.SbVec3d_getValue(self)


    def cross(self, v):
        """cross(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d_cross(self, v)


    def dot(self, v):
        """dot(SbVec3d self, SbVec3d v) -> double"""
        return _coin.SbVec3d_dot(self, v)


    def equals(self, v, tolerance):
        """equals(SbVec3d self, SbVec3d v, double tolerance) -> SbBool"""
        return _coin.SbVec3d_equals(self, v, tolerance)


    def getClosestAxis(self):
        """getClosestAxis(SbVec3d self) -> SbVec3d"""
        return _coin.SbVec3d_getClosestAxis(self)


    def length(self):
        """length(SbVec3d self) -> double"""
        return _coin.SbVec3d_length(self)


    def sqrLength(self):
        """sqrLength(SbVec3d self) -> double"""
        return _coin.SbVec3d_sqrLength(self)


    def negate(self):
        """negate(SbVec3d self)"""
        return _coin.SbVec3d_negate(self)


    def normalize(self):
        """normalize(SbVec3d self) -> double"""
        return _coin.SbVec3d_normalize(self)


    def __imul__(self, d):
        """__imul__(SbVec3d self, double d) -> SbVec3d"""
        return _coin.SbVec3d___imul__(self, d)


    def __idiv__(self, d):
        """__idiv__(SbVec3d self, double d) -> SbVec3d"""
        return _coin.SbVec3d___idiv__(self, d)


    def __iadd__(self, v):
        """__iadd__(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec3d self) -> SbVec3d"""
        return _coin.SbVec3d___neg__(self)


    def output(self, fp):
        """output(SbVec3d self, FILE * fp)"""
        return _coin.SbVec3d_output(self, fp)


    def __add__(self, u):
        """__add__(SbVec3d self, SbVec3d u) -> SbVec3d"""
        return _coin.SbVec3d___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbVec3d self, SbVec3d u) -> SbVec3d"""
        return _coin.SbVec3d___sub__(self, u)


    def __mul__(self, *args):
        """
        __mul__(SbVec3d self, double const d) -> SbVec3d
        __mul__(SbVec3d self, SbDPMatrix m) -> SbVec3d
        """
        return _coin.SbVec3d___mul__(self, *args)


    def __rmul__(self, d):
        """__rmul__(SbVec3d self, double const d) -> SbVec3d"""
        return _coin.SbVec3d___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbVec3d self, double const d) -> SbVec3d"""
        return _coin.SbVec3d___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbVec3d self, SbVec3d u) -> int"""
        return _coin.SbVec3d___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbVec3d self, SbVec3d u) -> int"""
        return _coin.SbVec3d___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbVec3d self, int i) -> double"""
        return _coin.SbVec3d___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SbVec3d self, int i, double value)"""
        return _coin.SbVec3d___setitem__(self, i, value)


    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__(SbDPViewVolume 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, affine, proj):
        """getMatrices(SbDPViewVolume self, SbDPMatrix affine, SbDPMatrix proj)"""
        return _coin.SbDPViewVolume_getMatrices(self, affine, proj)


    def getMatrix(self):
        """getMatrix(SbDPViewVolume self) -> SbDPMatrix"""
        return _coin.SbDPViewVolume_getMatrix(self)


    def getCameraSpaceMatrix(self):
        """getCameraSpaceMatrix(SbDPViewVolume self) -> SbDPMatrix"""
        return _coin.SbDPViewVolume_getCameraSpaceMatrix(self)


    def projectPointToLine(self, *args):
        """
        projectPointToLine(SbDPViewVolume self, SbVec2d pt, SbDPLine line)
        projectPointToLine(SbDPViewVolume self, SbVec2d pt, SbVec3d line0, SbVec3d line1)
        """
        return _coin.SbDPViewVolume_projectPointToLine(self, *args)


    def projectToScreen(self, src, dst):
        """projectToScreen(SbDPViewVolume self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPViewVolume_projectToScreen(self, src, dst)


    def getPlane(self, distFromEye):
        """getPlane(SbDPViewVolume self, double const distFromEye) -> SbPlane"""
        return _coin.SbDPViewVolume_getPlane(self, distFromEye)


    def getSightPoint(self, distFromEye):
        """getSightPoint(SbDPViewVolume self, double const distFromEye) -> SbVec3d"""
        return _coin.SbDPViewVolume_getSightPoint(self, distFromEye)


    def getPlanePoint(self, distFromEye, normPoint):
        """getPlanePoint(SbDPViewVolume self, double const distFromEye, SbVec2d normPoint) -> SbVec3d"""
        return _coin.SbDPViewVolume_getPlanePoint(self, distFromEye, normPoint)


    def getAlignRotation(self, rightAngleOnly=0):
        """
        getAlignRotation(SbDPViewVolume self, SbBool rightAngleOnly=0) -> SbDPRotation
        getAlignRotation(SbDPViewVolume self) -> SbDPRotation
        """
        return _coin.SbDPViewVolume_getAlignRotation(self, rightAngleOnly)


    def getWorldToScreenScale(self, worldCenter, normRadius):
        """getWorldToScreenScale(SbDPViewVolume self, SbVec3d worldCenter, double normRadius) -> double"""
        return _coin.SbDPViewVolume_getWorldToScreenScale(self, worldCenter, normRadius)


    def projectBox(self, box):
        """projectBox(SbDPViewVolume self, SbBox3f box) -> SbVec2d"""
        return _coin.SbDPViewVolume_projectBox(self, box)


    def narrow(self, *args):
        """
        narrow(SbDPViewVolume self, double left, double bottom, double right, double top) -> SbDPViewVolume
        narrow(SbDPViewVolume self, SbBox3f box) -> SbDPViewVolume
        """
        return _coin.SbDPViewVolume_narrow(self, *args)


    def ortho(self, left, right, bottom, top, nearval, farval):
        """ortho(SbDPViewVolume self, double left, double right, double bottom, double top, double nearval, double farval)"""
        return _coin.SbDPViewVolume_ortho(self, left, right, bottom, top, nearval, farval)


    def perspective(self, fovy, aspect, nearval, farval):
        """perspective(SbDPViewVolume self, double fovy, double aspect, double nearval, double farval)"""
        return _coin.SbDPViewVolume_perspective(self, fovy, aspect, nearval, farval)


    def frustum(self, left, right, bottom, top, nearval, farval):
        """frustum(SbDPViewVolume self, double left, double right, double bottom, double top, double nearval, double farval)"""
        return _coin.SbDPViewVolume_frustum(self, left, right, bottom, top, nearval, farval)


    def rotateCamera(self, q):
        """rotateCamera(SbDPViewVolume self, SbDPRotation q)"""
        return _coin.SbDPViewVolume_rotateCamera(self, q)


    def translateCamera(self, v):
        """translateCamera(SbDPViewVolume self, SbVec3d v)"""
        return _coin.SbDPViewVolume_translateCamera(self, v)


    def zVector(self):
        """zVector(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_zVector(self)


    def zNarrow(self, nearval, farval):
        """zNarrow(SbDPViewVolume self, double nearval, double farval) -> SbDPViewVolume"""
        return _coin.SbDPViewVolume_zNarrow(self, nearval, farval)


    def scale(self, factor):
        """scale(SbDPViewVolume self, double factor)"""
        return _coin.SbDPViewVolume_scale(self, factor)


    def scaleWidth(self, ratio):
        """scaleWidth(SbDPViewVolume self, double ratio)"""
        return _coin.SbDPViewVolume_scaleWidth(self, ratio)


    def scaleHeight(self, ratio):
        """scaleHeight(SbDPViewVolume self, double ratio)"""
        return _coin.SbDPViewVolume_scaleHeight(self, ratio)


    def getProjectionType(self):
        """getProjectionType(SbDPViewVolume self) -> SbDPViewVolume::ProjectionType"""
        return _coin.SbDPViewVolume_getProjectionType(self)


    def getProjectionPoint(self):
        """getProjectionPoint(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getProjectionPoint(self)


    def getProjectionDirection(self):
        """getProjectionDirection(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getProjectionDirection(self)


    def getNearDist(self):
        """getNearDist(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getNearDist(self)


    def getWidth(self):
        """getWidth(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getWidth(self)


    def getHeight(self):
        """getHeight(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getHeight(self)


    def getDepth(self):
        """getDepth(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getDepth(self)


    def output(self, fp):
        """output(SbDPViewVolume self, FILE * fp)"""
        return _coin.SbDPViewVolume_output(self, fp)


    def getViewVolumePlanes(self, planes):
        """getViewVolumePlanes(SbDPViewVolume self, SbPlane planes)"""
        return _coin.SbDPViewVolume_getViewVolumePlanes(self, planes)


    def transform(self, matrix):
        """transform(SbDPViewVolume self, SbDPMatrix matrix)"""
        return _coin.SbDPViewVolume_transform(self, matrix)


    def getViewUp(self):
        """getViewUp(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getViewUp(self)


    def copyValues(self, vv):
        """copyValues(SbDPViewVolume self, SbViewVolume vv)"""
        return _coin.SbDPViewVolume_copyValues(self, vv)

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__(SbViewVolume 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, affine, proj):
        """getMatrices(SbViewVolume self, SbMatrix affine, SbMatrix proj)"""
        return _coin.SbViewVolume_getMatrices(self, affine, proj)


    def getMatrix(self):
        """getMatrix(SbViewVolume self) -> SbMatrix"""
        return _coin.SbViewVolume_getMatrix(self)


    def getCameraSpaceMatrix(self):
        """getCameraSpaceMatrix(SbViewVolume self) -> SbMatrix"""
        return _coin.SbViewVolume_getCameraSpaceMatrix(self)


    def getPlane(self, distFromEye):
        """getPlane(SbViewVolume self, float const distFromEye) -> SbPlane"""
        return _coin.SbViewVolume_getPlane(self, distFromEye)


    def getSightPoint(self, distFromEye):
        """getSightPoint(SbViewVolume self, float const distFromEye) -> SbVec3f"""
        return _coin.SbViewVolume_getSightPoint(self, distFromEye)


    def getPlanePoint(self, distFromEye, normPoint):
        """getPlanePoint(SbViewVolume self, float const distFromEye, SbVec2f normPoint) -> SbVec3f"""
        return _coin.SbViewVolume_getPlanePoint(self, distFromEye, normPoint)


    def getAlignRotation(self, rightAngleOnly=0):
        """
        getAlignRotation(SbViewVolume self, SbBool rightAngleOnly=0) -> SbRotation
        getAlignRotation(SbViewVolume self) -> SbRotation
        """
        return _coin.SbViewVolume_getAlignRotation(self, rightAngleOnly)


    def getWorldToScreenScale(self, worldCenter, normRadius):
        """getWorldToScreenScale(SbViewVolume self, SbVec3f worldCenter, float normRadius) -> float"""
        return _coin.SbViewVolume_getWorldToScreenScale(self, worldCenter, normRadius)


    def projectBox(self, box):
        """projectBox(SbViewVolume self, SbBox3f box) -> SbVec2f"""
        return _coin.SbViewVolume_projectBox(self, box)


    def narrow(self, *args):
        """
        narrow(SbViewVolume self, float left, float bottom, float right, float top) -> SbViewVolume
        narrow(SbViewVolume self, SbBox3f box) -> SbViewVolume
        """
        return _coin.SbViewVolume_narrow(self, *args)


    def ortho(self, left, right, bottom, top, nearval, farval):
        """ortho(SbViewVolume self, float left, float right, float bottom, float top, float nearval, float farval)"""
        return _coin.SbViewVolume_ortho(self, left, right, bottom, top, nearval, farval)


    def perspective(self, fovy, aspect, nearval, farval):
        """perspective(SbViewVolume self, float fovy, float aspect, float nearval, float farval)"""
        return _coin.SbViewVolume_perspective(self, fovy, aspect, nearval, farval)


    def frustum(self, left, right, bottom, top, nearval, farval):
        """frustum(SbViewVolume self, float left, float right, float bottom, float top, float nearval, float farval)"""
        return _coin.SbViewVolume_frustum(self, left, right, bottom, top, nearval, farval)


    def rotateCamera(self, q):
        """rotateCamera(SbViewVolume self, SbRotation q)"""
        return _coin.SbViewVolume_rotateCamera(self, q)


    def translateCamera(self, v):
        """translateCamera(SbViewVolume self, SbVec3f v)"""
        return _coin.SbViewVolume_translateCamera(self, v)


    def zVector(self):
        """zVector(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_zVector(self)


    def zNarrow(self, nearval, farval):
        """zNarrow(SbViewVolume self, float nearval, float farval) -> SbViewVolume"""
        return _coin.SbViewVolume_zNarrow(self, nearval, farval)


    def scale(self, factor):
        """scale(SbViewVolume self, float factor)"""
        return _coin.SbViewVolume_scale(self, factor)


    def scaleWidth(self, ratio):
        """scaleWidth(SbViewVolume self, float ratio)"""
        return _coin.SbViewVolume_scaleWidth(self, ratio)


    def scaleHeight(self, ratio):
        """scaleHeight(SbViewVolume self, float ratio)"""
        return _coin.SbViewVolume_scaleHeight(self, ratio)


    def getProjectionType(self):
        """getProjectionType(SbViewVolume self) -> SbViewVolume::ProjectionType"""
        return _coin.SbViewVolume_getProjectionType(self)


    def getProjectionPoint(self):
        """getProjectionPoint(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getProjectionPoint(self)


    def getProjectionDirection(self):
        """getProjectionDirection(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getProjectionDirection(self)


    def getNearDist(self):
        """getNearDist(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getNearDist(self)


    def getWidth(self):
        """getWidth(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getWidth(self)


    def getHeight(self):
        """getHeight(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getHeight(self)


    def getDepth(self):
        """getDepth(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getDepth(self)


    def output(self, fp):
        """output(SbViewVolume self, FILE * fp)"""
        return _coin.SbViewVolume_output(self, fp)


    def getViewVolumePlanes(self, planes):
        """getViewVolumePlanes(SbViewVolume self, SbPlane planes)"""
        return _coin.SbViewVolume_getViewVolumePlanes(self, planes)


    def transform(self):
        """transform(SbViewVolume self)"""
        return _coin.SbViewVolume_transform(self)


    def getViewUp(self):
        """getViewUp(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getViewUp(self)


    def intersect(self, *args):
        """
        intersect(SbViewVolume self, SbVec3f p) -> SbBool
        intersect(SbViewVolume self, SbVec3f p0, SbVec3f p1, SbVec3f closestpoint) -> SbBool
        intersect(SbViewVolume self, SbBox3f box) -> SbBool
        """
        return _coin.SbViewVolume_intersect(self, *args)


    def outsideTest(self, p, bmin, bmax):
        """outsideTest(SbViewVolume self, SbPlane p, SbVec3f bmin, SbVec3f bmax) -> SbBool"""
        return _coin.SbViewVolume_outsideTest(self, p, bmin, bmax)


    def getDPViewVolume(self):
        """getDPViewVolume(SbViewVolume 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, pt):
        """projectPointToLine(SbVec3f) -> (SbVec3f, SbVec3f)"""
        return _coin.SbViewVolume_projectPointToLine(self, pt)


    def projectToScreen(self, src):
        """projectToScreen(SbVec3f) -> SbVec3f"""
        return _coin.SbViewVolume_projectToScreen(self, src)

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__(SoSFVec3f 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(SoSFVec3f self) -> SoType"""
        return _coin.SoSFVec3f_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec3f self, SoField field)"""
        return _coin.SoSFVec3f_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec3f self, SoField field) -> SbBool"""
        return _coin.SoSFVec3f_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec3f self) -> SbVec3f"""
        return _coin.SoSFVec3f_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec3f self, SoSFVec3f field) -> int"""
        return _coin.SoSFVec3f___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec3f self, SoSFVec3f field) -> int"""
        return _coin.SoSFVec3f___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec3f self, SbVec3f newvalue)
        setValue(SoSFVec3f self, float x, float y, float z)
        setValue(SoSFVec3f self, float const [3] xyz)
        setValue(SoSFVec3f 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(SoScale self) -> SoType"""
        return _coin.SoScale_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoScale 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, action):
        """doAction(SoScale self, SoAction action)"""
        return _coin.SoScale_doAction(self, action)


    def callback(self, action):
        """callback(SoScale self, SoCallbackAction action)"""
        return _coin.SoScale_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoScale self, SoGLRenderAction action)"""
        return _coin.SoScale_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoScale self, SoGetBoundingBoxAction action)"""
        return _coin.SoScale_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoScale self, SoGetMatrixAction action)"""
        return _coin.SoScale_getMatrix(self, action)


    def pick(self, action):
        """pick(SoScale self, SoPickAction action)"""
        return _coin.SoScale_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoScale self, SoGetPrimitiveCountAction action)"""
        return _coin.SoScale_getPrimitiveCount(self, action)

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(SoDragger self) -> SoType"""
        return _coin.SoDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoDragger 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, action):
        """callback(SoDragger self, SoCallbackAction action)"""
        return _coin.SoDragger_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoDragger self, SoGLRenderAction action)"""
        return _coin.SoDragger_GLRender(self, action)


    def getMatrix(self, action):
        """getMatrix(SoDragger self, SoGetMatrixAction action)"""
        return _coin.SoDragger_getMatrix(self, action)


    def rayPick(self, action):
        """rayPick(SoDragger self, SoRayPickAction action)"""
        return _coin.SoDragger_rayPick(self, action)


    def search(self, action):
        """search(SoDragger self, SoSearchAction action)"""
        return _coin.SoDragger_search(self, action)


    def write(self, action):
        """write(SoDragger self, SoWriteAction action)"""
        return _coin.SoDragger_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoDragger self, SoGetPrimitiveCountAction action)"""
        return _coin.SoDragger_getPrimitiveCount(self, action)


    def setProjectorEpsilon(self, epsilon):
        """setProjectorEpsilon(SoDragger self, float const epsilon)"""
        return _coin.SoDragger_setProjectorEpsilon(self, epsilon)


    def getProjectorEpsilon(self):
        """getProjectorEpsilon(SoDragger self) -> float"""
        return _coin.SoDragger_getProjectorEpsilon(self)


    def setMinGesture(self, pixels):
        """setMinGesture(SoDragger self, int pixels)"""
        return _coin.SoDragger_setMinGesture(self, pixels)


    def getMinGesture(self):
        """getMinGesture(SoDragger self) -> int"""
        return _coin.SoDragger_getMinGesture(self)


    def enableValueChangedCallbacks(self, newval):
        """enableValueChangedCallbacks(SoDragger self, SbBool newval) -> SbBool"""
        return _coin.SoDragger_enableValueChangedCallbacks(self, newval)


    def getMotionMatrix(self):
        """getMotionMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getMotionMatrix(self)


    def registerChildDragger(self, child):
        """registerChildDragger(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_registerChildDragger(self, child)


    def unregisterChildDragger(self, child):
        """unregisterChildDragger(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_unregisterChildDragger(self, child)


    def registerChildDraggerMovingIndependently(self, child):
        """registerChildDraggerMovingIndependently(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_registerChildDraggerMovingIndependently(self, child)


    def unregisterChildDraggerMovingIndependently(self, child):
        """unregisterChildDraggerMovingIndependently(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_unregisterChildDraggerMovingIndependently(self, child)


    def getLocalToWorldMatrix(self):
        """getLocalToWorldMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getLocalToWorldMatrix(self)


    def getWorldToLocalMatrix(self):
        """getWorldToLocalMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getWorldToLocalMatrix(self)


    def getLocalStartingPoint(self):
        """getLocalStartingPoint(SoDragger self) -> SbVec3f"""
        return _coin.SoDragger_getLocalStartingPoint(self)


    def getWorldStartingPoint(self):
        """getWorldStartingPoint(SoDragger self) -> SbVec3f"""
        return _coin.SoDragger_getWorldStartingPoint(self)


    def getPartToLocalMatrix(self, partname, parttolocalmatrix, localtopartmatrix):
        """getPartToLocalMatrix(SoDragger self, SbName partname, SbMatrix parttolocalmatrix, SbMatrix localtopartmatrix)"""
        return _coin.SoDragger_getPartToLocalMatrix(self, partname, parttolocalmatrix, localtopartmatrix)


    def transformMatrixLocalToWorld(self, frommatrix, tomatrix):
        """transformMatrixLocalToWorld(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"""
        return _coin.SoDragger_transformMatrixLocalToWorld(self, frommatrix, tomatrix)


    def transformMatrixWorldToLocal(self, frommatrix, tomatrix):
        """transformMatrixWorldToLocal(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"""
        return _coin.SoDragger_transformMatrixWorldToLocal(self, frommatrix, tomatrix)


    def transformMatrixToLocalSpace(self, frommatrix, tomatrix, fromspacepartname):
        """transformMatrixToLocalSpace(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix, SbName fromspacepartname)"""
        return _coin.SoDragger_transformMatrixToLocalSpace(self, frommatrix, tomatrix, fromspacepartname)


    def setMotionMatrix(self, newmatrix):
        """setMotionMatrix(SoDragger self, SbMatrix newmatrix)"""
        return _coin.SoDragger_setMotionMatrix(self, newmatrix)


    def valueChanged(self):
        """valueChanged(SoDragger self)"""
        return _coin.SoDragger_valueChanged(self)


    def getStartMotionMatrix(self):
        """getStartMotionMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getStartMotionMatrix(self)


    def saveStartParameters(self):
        """saveStartParameters(SoDragger self)"""
        return _coin.SoDragger_saveStartParameters(self)


    def getPickPath(self):
        """getPickPath(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getPickPath(self)


    def getEvent(self):
        """getEvent(SoDragger self) -> SoEvent"""
        return _coin.SoDragger_getEvent(self)


    def createPathToThis(self):
        """createPathToThis(SoDragger self) -> SoPath"""
        return _coin.SoDragger_createPathToThis(self)


    def getSurrogatePartPickedOwner(self):
        """getSurrogatePartPickedOwner(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getSurrogatePartPickedOwner(self)


    def getSurrogatePartPickedName(self):
        """getSurrogatePartPickedName(SoDragger self) -> SbName"""
        return _coin.SoDragger_getSurrogatePartPickedName(self)


    def getSurrogatePartPickedPath(self):
        """getSurrogatePartPickedPath(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getSurrogatePartPickedPath(self)


    def setStartingPoint(self, *args):
        """
        setStartingPoint(SoDragger self, SoPickedPoint newpoint)
        setStartingPoint(SoDragger self, SbVec3f newpoint)
        """
        return _coin.SoDragger_setStartingPoint(self, *args)


    def getViewVolume(self):
        """getViewVolume(SoDragger self) -> SbViewVolume"""
        return _coin.SoDragger_getViewVolume(self)


    def setViewVolume(self, vol):
        """setViewVolume(SoDragger self, SbViewVolume vol)"""
        return _coin.SoDragger_setViewVolume(self, vol)


    def getViewportRegion(self):
        """getViewportRegion(SoDragger self) -> SbViewportRegion"""
        return _coin.SoDragger_getViewportRegion(self)


    def setViewportRegion(self, reg):
        """setViewportRegion(SoDragger self, SbViewportRegion reg)"""
        return _coin.SoDragger_setViewportRegion(self, reg)


    def getHandleEventAction(self):
        """getHandleEventAction(SoDragger self) -> SoHandleEventAction"""
        return _coin.SoDragger_getHandleEventAction(self)


    def setHandleEventAction(self, newAction):
        """setHandleEventAction(SoDragger self, SoHandleEventAction newAction)"""
        return _coin.SoDragger_setHandleEventAction(self, newAction)


    def setTempPathToThis(self, somethingclose):
        """setTempPathToThis(SoDragger self, SoPath somethingclose)"""
        return _coin.SoDragger_setTempPathToThis(self, somethingclose)


    def grabEventsSetup(self):
        """grabEventsSetup(SoDragger self)"""
        return _coin.SoDragger_grabEventsSetup(self)


    def grabEventsCleanup(self):
        """grabEventsCleanup(SoDragger self)"""
        return _coin.SoDragger_grabEventsCleanup(self)


    def workFieldsIntoTransform(self, mtx):
        """workFieldsIntoTransform(SoDragger self, SbMatrix mtx)"""
        return _coin.SoDragger_workFieldsIntoTransform(self, mtx)


    def setFrontOnProjector(self, newval):
        """setFrontOnProjector(SoDragger self, SoDragger::ProjectorFrontSetting newval)"""
        return _coin.SoDragger_setFrontOnProjector(self, newval)


    def getFrontOnProjector(self):
        """getFrontOnProjector(SoDragger self) -> SoDragger::ProjectorFrontSetting"""
        return _coin.SoDragger_getFrontOnProjector(self)


    def setMinScale(newminscale):
        """setMinScale(float newminscale)"""
        return _coin.SoDragger_setMinScale(newminscale)

    setMinScale = staticmethod(setMinScale)

    def getMinScale():
        """getMinScale() -> float"""
        return _coin.SoDragger_getMinScale()

    getMinScale = staticmethod(getMinScale)

    def workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr):
        """workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, SbVec3f scalefactorptr, SbRotation scaleorientationptr, SbVec3f centerptr)"""
        return _coin.SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr)

    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(mtx, translation, conversion=None):
        """
        appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion=None) -> SbMatrix
        appendTranslation(SbMatrix mtx, SbVec3f translation) -> SbMatrix
        """
        return _coin.SoDragger_appendTranslation(mtx, translation, conversion)

    appendTranslation = staticmethod(appendTranslation)

    def appendScale(mtx, scale, scalecenter, conversion=None):
        """
        appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion=None) -> SbMatrix
        appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter) -> SbMatrix
        """
        return _coin.SoDragger_appendScale(mtx, scale, scalecenter, conversion)

    appendScale = staticmethod(appendScale)

    def appendRotation(mtx, rot, rotcenter, conversion=None):
        """
        appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion=None) -> SbMatrix
        appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter) -> SbMatrix
        """
        return _coin.SoDragger_appendRotation(mtx, rot, rotcenter, conversion)

    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(SoDragger self, SoDraggerCB * func, void * data=None)
        addStartCallback(SoDragger self, SoDraggerCB * func)
        addStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        addStartCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_addStartCallback(self, *args)


    def removeStartCallback(self, *args):
        """
        removeStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeStartCallback(SoDragger self, SoDraggerCB * func)
        removeStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        removeStartCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_removeStartCallback(self, *args)


    def addMotionCallback(self, *args):
        """
        addMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addMotionCallback(SoDragger self, SoDraggerCB * func)
        addMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        addMotionCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_addMotionCallback(self, *args)


    def removeMotionCallback(self, *args):
        """
        removeMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeMotionCallback(SoDragger self, SoDraggerCB * func)
        removeMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        removeMotionCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_removeMotionCallback(self, *args)


    def addFinishCallback(self, *args):
        """
        addFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addFinishCallback(SoDragger self, SoDraggerCB * func)
        addFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        addFinishCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_addFinishCallback(self, *args)


    def removeFinishCallback(self, *args):
        """
        removeFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeFinishCallback(SoDragger self, SoDraggerCB * func)
        removeFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        removeFinishCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_removeFinishCallback(self, *args)


    def addValueChangedCallback(self, *args):
        """
        addValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addValueChangedCallback(SoDragger self, SoDraggerCB * func)
        addValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        addValueChangedCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_addValueChangedCallback(self, *args)


    def removeValueChangedCallback(self, *args):
        """
        removeValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeValueChangedCallback(SoDragger self, SoDraggerCB * func)
        removeValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        removeValueChangedCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_removeValueChangedCallback(self, *args)


    def addOtherEventCallback(self, *args):
        """
        addOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addOtherEventCallback(SoDragger self, SoDraggerCB * func)
        addOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        addOtherEventCallback(SoDragger self, PyObject * pyfunc)
        """
        return _coin.SoDragger_addOtherEventCallback(self, *args)


    def removeOtherEventCallback(self, *args):
        """
        removeOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeOtherEventCallback(SoDragger self, SoDraggerCB * func)
        removeOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        removeOtherEventCallback(SoDragger 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(newminscale):
    """SoDragger_setMinScale(float newminscale)"""
    return _coin.SoDragger_setMinScale(newminscale)

def SoDragger_getMinScale():
    """SoDragger_getMinScale() -> float"""
    return _coin.SoDragger_getMinScale()

def SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr):
    """SoDragger_workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, SbVec3f scalefactorptr, SbRotation scaleorientationptr, SbVec3f centerptr)"""
    return _coin.SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr)

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(mtx, translation, conversion=None):
    """
    appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion=None) -> SbMatrix
    SoDragger_appendTranslation(SbMatrix mtx, SbVec3f translation) -> SbMatrix
    """
    return _coin.SoDragger_appendTranslation(mtx, translation, conversion)

def SoDragger_appendScale(mtx, scale, scalecenter, conversion=None):
    """
    appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion=None) -> SbMatrix
    SoDragger_appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter) -> SbMatrix
    """
    return _coin.SoDragger_appendScale(mtx, scale, scalecenter, conversion)

def SoDragger_appendRotation(mtx, rot, rotcenter, conversion=None):
    """
    appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion=None) -> SbMatrix
    SoDragger_appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter) -> SbMatrix
    """
    return _coin.SoDragger_appendRotation(mtx, rot, rotcenter, conversion)

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__(SoSFRotation 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(SoSFRotation self) -> SoType"""
        return _coin.SoSFRotation_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFRotation self, SoField field)"""
        return _coin.SoSFRotation_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFRotation self, SoField field) -> SbBool"""
        return _coin.SoSFRotation_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFRotation self, SoSFRotation field) -> int"""
        return _coin.SoSFRotation___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFRotation self, SoSFRotation field) -> int"""
        return _coin.SoSFRotation___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def getValue(self, *args):
        """
        getValue(SoSFRotation self) -> SbRotation
        getValue(SoSFRotation self, float & angle)
        """
        return _coin.SoSFRotation_getValue(self, *args)


    def setValue(self, *args):
        """
        setValue(SoSFRotation self, SbRotation newvalue)
        setValue(SoSFRotation self, float const q0, float const q1, float const q2, float const q3)
        setValue(SoSFRotation self, float const [4] q)
        setValue(SoSFRotation self, SbVec3f axis, float const angle)
        setValue(SoSFRotation 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(SoCenterballDragger self) -> SoType"""
        return _coin.SoCenterballDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoCenterballDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoCenterballDragger self) -> SoNodekitCatalog"""
        return _coin.SoCenterballDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCenterballDragger self) -> SoCenterballDragger"""
        this = _coin.new_SoCenterballDragger()
        try:
            self.this.append(this)
        except:
            self.this = this

    def saveStartParameters(self):
        """saveStartParameters(SoCenterballDragger 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(SoDirectionalLightDragger self) -> SoType"""
        return _coin.SoDirectionalLightDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDirectionalLightDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoDirectionalLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoDirectionalLightDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoDirectionalLightDragger 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(SoDragPointDragger self) -> SoType"""
        return _coin.SoDragPointDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDragPointDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoDragPointDragger self) -> SoNodekitCatalog"""
        return _coin.SoDragPointDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoDragPointDragger 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, limit):
        """setJumpLimit(SoDragPointDragger self, float const limit)"""
        return _coin.SoDragPointDragger_setJumpLimit(self, limit)


    def getJumpLimit(self):
        """getJumpLimit(SoDragPointDragger self) -> float"""
        return _coin.SoDragPointDragger_getJumpLimit(self)


    def showNextDraggerSet(self):
        """showNextDraggerSet(SoDragPointDragger 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(SoHandleBoxDragger self) -> SoType"""
        return _coin.SoHandleBoxDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoHandleBoxDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoHandleBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoHandleBoxDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoHandleBoxDragger 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(SoJackDragger self) -> SoType"""
        return _coin.SoJackDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoJackDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoJackDragger self) -> SoNodekitCatalog"""
        return _coin.SoJackDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoJackDragger 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(SoPointLightDragger self) -> SoType"""
        return _coin.SoPointLightDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoPointLightDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoPointLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoPointLightDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPointLightDragger 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(SoRotateCylindricalDragger self) -> SoType"""
        return _coin.SoRotateCylindricalDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateCylindricalDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoRotateCylindricalDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateCylindricalDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoRotateCylindricalDragger 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, p):
        """setProjector(SoRotateCylindricalDragger self, SbCylinderProjector p)"""
        return _coin.SoRotateCylindricalDragger_setProjector(self, p)


    def getProjector(self):
        """getProjector(SoRotateCylindricalDragger 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(SoRotateDiscDragger self) -> SoType"""
        return _coin.SoRotateDiscDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateDiscDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoRotateDiscDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateDiscDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoRotateDiscDragger 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(SoRotateSphericalDragger self) -> SoType"""
        return _coin.SoRotateSphericalDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateSphericalDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoRotateSphericalDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateSphericalDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoRotateSphericalDragger 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, p):
        """setProjector(SoRotateSphericalDragger self, SbSphereProjector p)"""
        return _coin.SoRotateSphericalDragger_setProjector(self, p)


    def getProjector(self):
        """getProjector(SoRotateSphericalDragger 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(SoScale1Dragger self) -> SoType"""
        return _coin.SoScale1Dragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale1Dragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoScale1Dragger self) -> SoNodekitCatalog"""
        return _coin.SoScale1Dragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoScale1Dragger 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(SoScale2Dragger self) -> SoType"""
        return _coin.SoScale2Dragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale2Dragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoScale2Dragger self) -> SoNodekitCatalog"""
        return _coin.SoScale2Dragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoScale2Dragger 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(SoScale2UniformDragger self) -> SoType"""
        return _coin.SoScale2UniformDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale2UniformDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoScale2UniformDragger self) -> SoNodekitCatalog"""
        return _coin.SoScale2UniformDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoScale2UniformDragger 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(SoScaleUniformDragger self) -> SoType"""
        return _coin.SoScaleUniformDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScaleUniformDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoScaleUniformDragger self) -> SoNodekitCatalog"""
        return _coin.SoScaleUniformDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoScaleUniformDragger 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(SoSpotLightDragger self) -> SoType"""
        return _coin.SoSpotLightDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSpotLightDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoSpotLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoSpotLightDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSpotLightDragger 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(SoTabBoxDragger self) -> SoType"""
        return _coin.SoTabBoxDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTabBoxDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoTabBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoTabBoxDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTabBoxDragger 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(SoTabBoxDragger 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(SoTabPlaneDragger self) -> SoType"""
        return _coin.SoTabPlaneDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTabPlaneDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoTabPlaneDragger self) -> SoNodekitCatalog"""
        return _coin.SoTabPlaneDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTabPlaneDragger 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(SoTabPlaneDragger 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(SoTrackballDragger self) -> SoType"""
        return _coin.SoTrackballDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTrackballDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoTrackballDragger self) -> SoNodekitCatalog"""
        return _coin.SoTrackballDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTrackballDragger 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(SoTrackballDragger self) -> SbBool"""
        return _coin.SoTrackballDragger_isAnimationEnabled(self)


    def setAnimationEnabled(self, newval):
        """setAnimationEnabled(SoTrackballDragger self, SbBool newval)"""
        return _coin.SoTrackballDragger_setAnimationEnabled(self, newval)

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(SoTransformBoxDragger self) -> SoType"""
        return _coin.SoTransformBoxDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTransformBoxDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoTransformBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoTransformBoxDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTransformBoxDragger 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(SoTransformerDragger self) -> SoType"""
        return _coin.SoTransformerDragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTransformerDragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoTransformerDragger self) -> SoNodekitCatalog"""
        return _coin.SoTransformerDragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTransformerDragger 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(SoTransformerDragger self) -> SoTransformerDragger::State"""
        return _coin.SoTransformerDragger_getCurrentState(self)


    def unsquishKnobs(self):
        """unsquishKnobs(SoTransformerDragger self)"""
        return _coin.SoTransformerDragger_unsquishKnobs(self)


    def isLocateHighlighting(self):
        """isLocateHighlighting(SoTransformerDragger self) -> SbBool"""
        return _coin.SoTransformerDragger_isLocateHighlighting(self)


    def setLocateHighlighting(self, onoff):
        """setLocateHighlighting(SoTransformerDragger self, SbBool onoff)"""
        return _coin.SoTransformerDragger_setLocateHighlighting(self, onoff)


    def setColinearThreshold(newval):
        """setColinearThreshold(int newval)"""
        return _coin.SoTransformerDragger_setColinearThreshold(newval)

    setColinearThreshold = staticmethod(setColinearThreshold)

    def getColinearThreshold():
        """getColinearThreshold() -> int"""
        return _coin.SoTransformerDragger_getColinearThreshold()

    getColinearThreshold = staticmethod(getColinearThreshold)

    def getBoxPointInWorldSpace(self, pointonunitbox):
        """getBoxPointInWorldSpace(SoTransformerDragger self, SbVec3f pointonunitbox) -> SbVec3f"""
        return _coin.SoTransformerDragger_getBoxPointInWorldSpace(self, pointonunitbox)


    def getBoxDirInWorldSpace(self, dironunitbox):
        """getBoxDirInWorldSpace(SoTransformerDragger self, SbVec3f dironunitbox) -> SbVec3f"""
        return _coin.SoTransformerDragger_getBoxDirInWorldSpace(self, dironunitbox)


    def getWorldPointInBoxSpace(self, pointinworldspace):
        """getWorldPointInBoxSpace(SoTransformerDragger self, SbVec3f pointinworldspace) -> SbVec3f"""
        return _coin.SoTransformerDragger_getWorldPointInBoxSpace(self, pointinworldspace)


    def getWorldPointInPixelSpace(self, thepoint):
        """getWorldPointInPixelSpace(SoTransformerDragger self, SbVec3f thepoint) -> SbVec2f"""
        return _coin.SoTransformerDragger_getWorldPointInPixelSpace(self, thepoint)


    def getInteractiveCenterInBoxSpace(self):
        """getInteractiveCenterInBoxSpace(SoTransformerDragger 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(newval):
    """SoTransformerDragger_setColinearThreshold(int newval)"""
    return _coin.SoTransformerDragger_setColinearThreshold(newval)

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(SoTranslate1Dragger self) -> SoType"""
        return _coin.SoTranslate1Dragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTranslate1Dragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoTranslate1Dragger self) -> SoNodekitCatalog"""
        return _coin.SoTranslate1Dragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTranslate1Dragger 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__(SoSFVec2f 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(SoSFVec2f self) -> SoType"""
        return _coin.SoSFVec2f_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec2f self, SoField field)"""
        return _coin.SoSFVec2f_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec2f self, SoField field) -> SbBool"""
        return _coin.SoSFVec2f_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec2f self) -> SbVec2f"""
        return _coin.SoSFVec2f_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec2f self, SoSFVec2f field) -> int"""
        return _coin.SoSFVec2f___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec2f self, SoSFVec2f field) -> int"""
        return _coin.SoSFVec2f___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec2f self, SbVec2f newvalue)
        setValue(SoSFVec2f self, float x, float y)
        setValue(SoSFVec2f self, float const [2] xy)
        setValue(SoSFVec2f 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(SoTranslate2Dragger self) -> SoType"""
        return _coin.SoTranslate2Dragger_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTranslate2Dragger_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoTranslate2Dragger self) -> SoNodekitCatalog"""
        return _coin.SoTranslate2Dragger_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTranslate2Dragger 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, element):
        """matches(SoAccumulatedElement self, SoElement element) -> SbBool"""
        return _coin.SoAccumulatedElement_matches(self, element)

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, state):
        """init(SoAmbientColorElement self, SoState state)"""
        return _coin.SoAmbientColorElement_init(self, state)


    def set(state, node, numcolors, colors):
        """set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoAmbientColorElement_set(state, node, numcolors, colors)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoAmbientColorElement"""
        return _coin.SoAmbientColorElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoAmbientColorElement self) -> int32_t"""
        return _coin.SoAmbientColorElement_getNum(self)


    def get(self, index):
        """get(SoAmbientColorElement self, int const index) -> SbColor"""
        return _coin.SoAmbientColorElement_get(self, index)


    def getArrayPtr(self):
        """getArrayPtr(SoAmbientColorElement 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(state, node, numcolors, colors):
    """SoAmbientColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
    return _coin.SoAmbientColorElement_set(state, node, numcolors, colors)

def SoAmbientColorElement_getInstance(state):
    """SoAmbientColorElement_getInstance(SoState state) -> SoAmbientColorElement"""
    return _coin.SoAmbientColorElement_getInstance(state)

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, state):
        """init(SoAnnoText3CharOrientElement self, SoState state)"""
        return _coin.SoAnnoText3CharOrientElement_init(self, state)


    def set(state, isOriented):
        """set(SoState state, SbBool isOriented)"""
        return _coin.SoAnnoText3CharOrientElement_set(state, isOriented)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbBool"""
        return _coin.SoAnnoText3CharOrientElement_get(state)

    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(state, isOriented):
    """SoAnnoText3CharOrientElement_set(SoState state, SbBool isOriented)"""
    return _coin.SoAnnoText3CharOrientElement_set(state, isOriented)

def SoAnnoText3CharOrientElement_get(state):
    """SoAnnoText3CharOrientElement_get(SoState state) -> SbBool"""
    return _coin.SoAnnoText3CharOrientElement_get(state)

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, state):
        """init(SoAnnoText3FontSizeHintElement self, SoState state)"""
        return _coin.SoAnnoText3FontSizeHintElement_init(self, state)


    def get(state):
        """get(SoState state) -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
        return _coin.SoAnnoText3FontSizeHintElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
        return _coin.SoAnnoText3FontSizeHintElement_getDefault()

    getDefault = staticmethod(getDefault)

    def set(*args):
        """
        set(SoState state, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
        set(SoState state, SoNode node, SoAnnoText3FontSizeHintElement::FontSizeHint const 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(state):
    """SoAnnoText3FontSizeHintElement_get(SoState state) -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
    return _coin.SoAnnoText3FontSizeHintElement_get(state)

def SoAnnoText3FontSizeHintElement_getDefault():
    """SoAnnoText3FontSizeHintElement_getDefault() -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
    return _coin.SoAnnoText3FontSizeHintElement_getDefault()

def SoAnnoText3FontSizeHintElement_set(*args):
    """
    set(SoState state, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
    SoAnnoText3FontSizeHintElement_set(SoState state, SoNode node, SoAnnoText3FontSizeHintElement::FontSizeHint const 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, state):
        """init(SoAnnoText3RenderPrintElement self, SoState state)"""
        return _coin.SoAnnoText3RenderPrintElement_init(self, state)


    def get(state):
        """get(SoState state) -> SoAnnoText3RenderPrintElement::RenderPrintType"""
        return _coin.SoAnnoText3RenderPrintElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoAnnoText3RenderPrintElement::RenderPrintType"""
        return _coin.SoAnnoText3RenderPrintElement_getDefault()

    getDefault = staticmethod(getDefault)

    def set(*args):
        """
        set(SoState state, SoAnnoText3RenderPrintElement::RenderPrintType const hint)
        set(SoState state, SoNode node, SoAnnoText3RenderPrintElement::RenderPrintType const 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(state):
    """SoAnnoText3RenderPrintElement_get(SoState state) -> SoAnnoText3RenderPrintElement::RenderPrintType"""
    return _coin.SoAnnoText3RenderPrintElement_get(state)

def SoAnnoText3RenderPrintElement_getDefault():
    """SoAnnoText3RenderPrintElement_getDefault() -> SoAnnoText3RenderPrintElement::RenderPrintType"""
    return _coin.SoAnnoText3RenderPrintElement_getDefault()

def SoAnnoText3RenderPrintElement_set(*args):
    """
    set(SoState state, SoAnnoText3RenderPrintElement::RenderPrintType const hint)
    SoAnnoText3RenderPrintElement_set(SoState state, SoNode node, SoAnnoText3RenderPrintElement::RenderPrintType const 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, state):
        """init(SoModelMatrixElement self, SoState state)"""
        return _coin.SoModelMatrixElement_init(self, state)


    def push(self, state):
        """push(SoModelMatrixElement self, SoState state)"""
        return _coin.SoModelMatrixElement_push(self, state)


    def matches(self, element):
        """matches(SoModelMatrixElement self, SoElement element) -> SbBool"""
        return _coin.SoModelMatrixElement_matches(self, element)


    def makeIdentity(state, node):
        """makeIdentity(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_makeIdentity(state, node)

    makeIdentity = staticmethod(makeIdentity)

    def set(state, node):
        """set(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_set(state, node)

    set = staticmethod(set)

    def setCullMatrix(state, node):
        """setCullMatrix(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_setCullMatrix(state, node)

    setCullMatrix = staticmethod(setCullMatrix)

    def mult(state, node):
        """mult(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_mult(state, node)

    mult = staticmethod(mult)

    def translateBy(state, node, translation):
        """translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoModelMatrixElement_translateBy(state, node, translation)

    translateBy = staticmethod(translateBy)

    def rotateBy(state, node, rotation):
        """rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoModelMatrixElement_rotateBy(state, node, rotation)

    rotateBy = staticmethod(rotateBy)

    def scaleBy(state, node, scaleFactor):
        """scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoModelMatrixElement_scaleBy(state, node, scaleFactor)

    scaleBy = staticmethod(scaleBy)

    def pushMatrix(state):
        """pushMatrix(SoState state) -> SbMatrix"""
        return _coin.SoModelMatrixElement_pushMatrix(state)

    pushMatrix = staticmethod(pushMatrix)

    def popMatrix(state):
        """popMatrix(SoState state)"""
        return _coin.SoModelMatrixElement_popMatrix(state)

    popMatrix = staticmethod(popMatrix)

    def getCombinedCullMatrix(state):
        """getCombinedCullMatrix(SoState state) -> SbMatrix"""
        return _coin.SoModelMatrixElement_getCombinedCullMatrix(state)

    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(SoModelMatrixElement 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(state, node):
    """SoModelMatrixElement_makeIdentity(SoState state, SoNode node)"""
    return _coin.SoModelMatrixElement_makeIdentity(state, node)

def SoModelMatrixElement_set(state, node):
    """SoModelMatrixElement_set(SoState state, SoNode node)"""
    return _coin.SoModelMatrixElement_set(state, node)

def SoModelMatrixElement_setCullMatrix(state, node):
    """SoModelMatrixElement_setCullMatrix(SoState state, SoNode node)"""
    return _coin.SoModelMatrixElement_setCullMatrix(state, node)

def SoModelMatrixElement_mult(state, node):
    """SoModelMatrixElement_mult(SoState state, SoNode node)"""
    return _coin.SoModelMatrixElement_mult(state, node)

def SoModelMatrixElement_translateBy(state, node, translation):
    """SoModelMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
    return _coin.SoModelMatrixElement_translateBy(state, node, translation)

def SoModelMatrixElement_rotateBy(state, node, rotation):
    """SoModelMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
    return _coin.SoModelMatrixElement_rotateBy(state, node, rotation)

def SoModelMatrixElement_scaleBy(state, node, scaleFactor):
    """SoModelMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
    return _coin.SoModelMatrixElement_scaleBy(state, node, scaleFactor)

def SoModelMatrixElement_pushMatrix(state):
    """SoModelMatrixElement_pushMatrix(SoState state) -> SbMatrix"""
    return _coin.SoModelMatrixElement_pushMatrix(state)

def SoModelMatrixElement_popMatrix(state):
    """SoModelMatrixElement_popMatrix(SoState state)"""
    return _coin.SoModelMatrixElement_popMatrix(state)

def SoModelMatrixElement_getCombinedCullMatrix(state):
    """SoModelMatrixElement_getCombinedCullMatrix(SoState state) -> SbMatrix"""
    return _coin.SoModelMatrixElement_getCombinedCullMatrix(state)

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, state):
        """init(SoBBoxModelMatrixElement self, SoState state)"""
        return _coin.SoBBoxModelMatrixElement_init(self, state)


    def push(self, state):
        """push(SoBBoxModelMatrixElement self, SoState state)"""
        return _coin.SoBBoxModelMatrixElement_push(self, state)


    def reset(state, node):
        """reset(SoState state, SoNode node)"""
        return _coin.SoBBoxModelMatrixElement_reset(state, node)

    reset = staticmethod(reset)

    def pushMatrix(state, localmatrix):
        """pushMatrix(SoState state, SbMatrix localmatrix)"""
        return _coin.SoBBoxModelMatrixElement_pushMatrix(state, localmatrix)

    pushMatrix = staticmethod(pushMatrix)

    def popMatrix(state, localmatrix):
        """popMatrix(SoState state, SbMatrix localmatrix)"""
        return _coin.SoBBoxModelMatrixElement_popMatrix(state, localmatrix)

    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(state, node):
    """SoBBoxModelMatrixElement_reset(SoState state, SoNode node)"""
    return _coin.SoBBoxModelMatrixElement_reset(state, node)

def SoBBoxModelMatrixElement_pushMatrix(state, localmatrix):
    """SoBBoxModelMatrixElement_pushMatrix(SoState state, SbMatrix localmatrix)"""
    return _coin.SoBBoxModelMatrixElement_pushMatrix(state, localmatrix)

def SoBBoxModelMatrixElement_popMatrix(state, localmatrix):
    """SoBBoxModelMatrixElement_popMatrix(SoState state, SbMatrix localmatrix)"""
    return _coin.SoBBoxModelMatrixElement_popMatrix(state, localmatrix)

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, state):
        """init(SoBumpMapCoordinateElement self, SoState state)"""
        return _coin.SoBumpMapCoordinateElement_init(self, state)


    def set(state, node, numcoords, coords):
        """set(SoState state, SoNode node, int32_t const numcoords, SbVec2f coords)"""
        return _coin.SoBumpMapCoordinateElement_set(state, node, numcoords, coords)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoBumpMapCoordinateElement"""
        return _coin.SoBumpMapCoordinateElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoBumpMapCoordinateElement self) -> int32_t"""
        return _coin.SoBumpMapCoordinateElement_getNum(self)


    def get(self, index):
        """get(SoBumpMapCoordinateElement self, int const index) -> SbVec2f"""
        return _coin.SoBumpMapCoordinateElement_get(self, index)


    def getArrayPtr(self):
        """getArrayPtr(SoBumpMapCoordinateElement 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(state, node, numcoords, coords):
    """SoBumpMapCoordinateElement_set(SoState state, SoNode node, int32_t const numcoords, SbVec2f coords)"""
    return _coin.SoBumpMapCoordinateElement_set(state, node, numcoords, coords)

def SoBumpMapCoordinateElement_getInstance(state):
    """SoBumpMapCoordinateElement_getInstance(SoState state) -> SoBumpMapCoordinateElement"""
    return _coin.SoBumpMapCoordinateElement_getInstance(state)

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, state):
        """init(SoBumpMapElement self, SoState state)"""
        return _coin.SoBumpMapElement_init(self, state)


    def set(state, node, image):
        """set(SoState state, SoNode node, SoGLImage image)"""
        return _coin.SoBumpMapElement_set(state, node, image)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoGLImage"""
        return _coin.SoBumpMapElement_get(state)

    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(state, node, image):
    """SoBumpMapElement_set(SoState state, SoNode node, SoGLImage image)"""
    return _coin.SoBumpMapElement_set(state, node, image)

def SoBumpMapElement_get(state):
    """SoBumpMapElement_get(SoState state) -> SoGLImage"""
    return _coin.SoBumpMapElement_get(state)

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, state):
        """init(SoBumpMapMatrixElement self, SoState state)"""
        return _coin.SoBumpMapMatrixElement_init(self, state)


    def push(self, state):
        """push(SoBumpMapMatrixElement self, SoState state)"""
        return _coin.SoBumpMapMatrixElement_push(self, state)


    def makeIdentity(state, node):
        """makeIdentity(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_makeIdentity(state, node)

    makeIdentity = staticmethod(makeIdentity)

    def set(state, node):
        """set(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_set(state, node)

    set = staticmethod(set)

    def mult(state, node):
        """mult(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_mult(state, node)

    mult = staticmethod(mult)

    def translateBy(state, node, translation):
        """translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoBumpMapMatrixElement_translateBy(state, node, translation)

    translateBy = staticmethod(translateBy)

    def rotateBy(state, node, rotation):
        """rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoBumpMapMatrixElement_rotateBy(state, node, rotation)

    rotateBy = staticmethod(rotateBy)

    def scaleBy(state, node, scaleFactor):
        """scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor)

    scaleBy = staticmethod(scaleBy)

    def get(state):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoBumpMapMatrixElement_get(state)

    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(state, node):
    """SoBumpMapMatrixElement_makeIdentity(SoState state, SoNode node)"""
    return _coin.SoBumpMapMatrixElement_makeIdentity(state, node)

def SoBumpMapMatrixElement_set(state, node):
    """SoBumpMapMatrixElement_set(SoState state, SoNode node)"""
    return _coin.SoBumpMapMatrixElement_set(state, node)

def SoBumpMapMatrixElement_mult(state, node):
    """SoBumpMapMatrixElement_mult(SoState state, SoNode node)"""
    return _coin.SoBumpMapMatrixElement_mult(state, node)

def SoBumpMapMatrixElement_translateBy(state, node, translation):
    """SoBumpMapMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
    return _coin.SoBumpMapMatrixElement_translateBy(state, node, translation)

def SoBumpMapMatrixElement_rotateBy(state, node, rotation):
    """SoBumpMapMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
    return _coin.SoBumpMapMatrixElement_rotateBy(state, node, rotation)

def SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor):
    """SoBumpMapMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
    return _coin.SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor)

def SoBumpMapMatrixElement_get(state):
    """SoBumpMapMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoBumpMapMatrixElement_get(state)

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, state):
        """init(SoCacheElement self, SoState state)"""
        return _coin.SoCacheElement_init(self, state)


    def push(self, state):
        """push(SoCacheElement self, SoState state)"""
        return _coin.SoCacheElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoCacheElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoCacheElement_pop(self, state, prevTopElement)


    def set(state, cache):
        """set(SoState state, SoCache cache)"""
        return _coin.SoCacheElement_set(state, cache)

    set = staticmethod(set)

    def getCache(self):
        """getCache(SoCacheElement self) -> SoCache"""
        return _coin.SoCacheElement_getCache(self)


    def anyOpen(state):
        """anyOpen(SoState state) -> SbBool"""
        return _coin.SoCacheElement_anyOpen(state)

    anyOpen = staticmethod(anyOpen)

    def invalidate(state):
        """invalidate(SoState state)"""
        return _coin.SoCacheElement_invalidate(state)

    invalidate = staticmethod(invalidate)

    def matches(self, element):
        """matches(SoCacheElement self, SoElement element) -> SbBool"""
        return _coin.SoCacheElement_matches(self, element)


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


    def getNextCacheElement(self):
        """getNextCacheElement(SoCacheElement self) -> SoCacheElement"""
        return _coin.SoCacheElement_getNextCacheElement(self)


    def addElement(state, element):
        """addElement(SoState state, SoElement element)"""
        return _coin.SoCacheElement_addElement(state, element)

    addElement = staticmethod(addElement)

    def addCacheDependency(state, cache):
        """addCacheDependency(SoState state, SoCache cache)"""
        return _coin.SoCacheElement_addCacheDependency(state, cache)

    addCacheDependency = staticmethod(addCacheDependency)

    def setInvalid(newvalue):
        """setInvalid(SbBool const newvalue) -> SbBool"""
        return _coin.SoCacheElement_setInvalid(newvalue)

    setInvalid = staticmethod(setInvalid)

    def getCurrentCache(state):
        """getCurrentCache(SoState state) -> SoCache"""
        return _coin.SoCacheElement_getCurrentCache(state)

    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(state, cache):
    """SoCacheElement_set(SoState state, SoCache cache)"""
    return _coin.SoCacheElement_set(state, cache)

def SoCacheElement_anyOpen(state):
    """SoCacheElement_anyOpen(SoState state) -> SbBool"""
    return _coin.SoCacheElement_anyOpen(state)

def SoCacheElement_invalidate(state):
    """SoCacheElement_invalidate(SoState state)"""
    return _coin.SoCacheElement_invalidate(state)

def SoCacheElement_addElement(state, element):
    """SoCacheElement_addElement(SoState state, SoElement element)"""
    return _coin.SoCacheElement_addElement(state, element)

def SoCacheElement_addCacheDependency(state, cache):
    """SoCacheElement_addCacheDependency(SoState state, SoCache cache)"""
    return _coin.SoCacheElement_addCacheDependency(state, cache)

def SoCacheElement_setInvalid(newvalue):
    """SoCacheElement_setInvalid(SbBool const newvalue) -> SbBool"""
    return _coin.SoCacheElement_setInvalid(newvalue)

def SoCacheElement_getCurrentCache(state):
    """SoCacheElement_getCurrentCache(SoState state) -> SoCache"""
    return _coin.SoCacheElement_getCurrentCache(state)

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__(SbPlane self) -> SbPlane
        __init__(SbPlane self, SbVec3f normal, float const D) -> SbPlane
        __init__(SbPlane self, SbVec3f p0, SbVec3f p1, SbVec3f p2) -> SbPlane
        __init__(SbPlane self, SbVec3f normal, SbVec3f point) -> SbPlane
        """
        this = _coin.new_SbPlane(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def offset(self, d):
        """offset(SbPlane self, float const d)"""
        return _coin.SbPlane_offset(self, d)


    def transform(self):
        """transform(SbPlane self)"""
        return _coin.SbPlane_transform(self)


    def isInHalfSpace(self, point):
        """isInHalfSpace(SbPlane self, SbVec3f point) -> SbBool"""
        return _coin.SbPlane_isInHalfSpace(self, point)


    def getDistance(self, point):
        """getDistance(SbPlane self, SbVec3f point) -> float"""
        return _coin.SbPlane_getDistance(self, point)


    def getNormal(self):
        """getNormal(SbPlane self) -> SbVec3f"""
        return _coin.SbPlane_getNormal(self)


    def getDistanceFromOrigin(self):
        """getDistanceFromOrigin(SbPlane self) -> float"""
        return _coin.SbPlane_getDistanceFromOrigin(self)


    def output(self, file):
        """output(SbPlane self, FILE * file)"""
        return _coin.SbPlane_output(self, file)


    def intersect(self, *args):
        """
        intersect(SbPlane self, SbLine l, SbVec3f intersection) -> SbBool
        intersect(SbPlane self, SbPlane pl, SbLine line) -> SbBool
        """
        return _coin.SbPlane_intersect(self, *args)


    def __eq__(self, u):
        """__eq__(SbPlane self, SbPlane u) -> int"""
        return _coin.SbPlane___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbPlane self, SbPlane u) -> int"""
        return _coin.SbPlane___ne__(self, u)

    __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, state):
        """init(SoClipPlaneElement self, SoState state)"""
        return _coin.SoClipPlaneElement_init(self, state)


    def push(self, state):
        """push(SoClipPlaneElement self, SoState state)"""
        return _coin.SoClipPlaneElement_push(self, state)


    def add(state, node, plane):
        """add(SoState state, SoNode node, SbPlane plane)"""
        return _coin.SoClipPlaneElement_add(state, node, plane)

    add = staticmethod(add)

    def getInstance(state):
        """getInstance(SoState state) -> SoClipPlaneElement"""
        return _coin.SoClipPlaneElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoClipPlaneElement self) -> int"""
        return _coin.SoClipPlaneElement_getNum(self)


    def get(self, index, inworldspace=1):
        """
        get(SoClipPlaneElement self, int const index, SbBool const inworldspace=1) -> SbPlane
        get(SoClipPlaneElement self, int const index) -> SbPlane
        """
        return _coin.SoClipPlaneElement_get(self, index, inworldspace)

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(state, node, plane):
    """SoClipPlaneElement_add(SoState state, SoNode node, SbPlane plane)"""
    return _coin.SoClipPlaneElement_add(state, node, plane)

def SoClipPlaneElement_getInstance(state):
    """SoClipPlaneElement_getInstance(SoState state) -> SoClipPlaneElement"""
    return _coin.SoClipPlaneElement_getInstance(state)

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, state):
        """init(SoFloatElement self, SoState state)"""
        return _coin.SoFloatElement_init(self, state)


    def matches(self, element):
        """matches(SoFloatElement self, SoElement element) -> SbBool"""
        return _coin.SoFloatElement_matches(self, element)


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


    def output(self, file):
        """output(SoFloatElement self, FILE * file)"""
        return _coin.SoFloatElement_output(self, file)


    def set(*args):
        """
        set(int const stackIndex, SoState state, SoNode node, float const value)
        set(int const stackIndex, SoState state, float const value)
        """
        return _coin.SoFloatElement_set(*args)

    set = staticmethod(set)

    def get(stackIndex, state):
        """get(int const stackIndex, SoState state) -> float"""
        return _coin.SoFloatElement_get(stackIndex, state)

    get = staticmethod(get)

    def setElt(self, value):
        """setElt(SoFloatElement self, float value)"""
        return _coin.SoFloatElement_setElt(self, value)

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 const stackIndex, SoState state, SoNode node, float const value)
    SoFloatElement_set(int const stackIndex, SoState state, float const value)
    """
    return _coin.SoFloatElement_set(*args)

def SoFloatElement_get(stackIndex, state):
    """SoFloatElement_get(int const stackIndex, SoState state) -> float"""
    return _coin.SoFloatElement_get(stackIndex, state)

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, state):
        """init(SoComplexityElement self, SoState state)"""
        return _coin.SoComplexityElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoComplexityElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> float"""
        return _coin.SoComplexityElement_get(state)

    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 const complexity)
    SoComplexityElement_set(SoState state, float const complexity)
    """
    return _coin.SoComplexityElement_set(*args)

def SoComplexityElement_get(state):
    """SoComplexityElement_get(SoState state) -> float"""
    return _coin.SoComplexityElement_get(state)

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, state):
        """init(SoCoordinateElement self, SoState state)"""
        return _coin.SoCoordinateElement_init(self, state)


    def set3(state, node, numCoords, coords):
        """set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoCoordinateElement_set3(state, node, numCoords, coords)

    set3 = staticmethod(set3)

    def set4(state, node, numCoords, coords):
        """set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
        return _coin.SoCoordinateElement_set4(state, node, numCoords, coords)

    set4 = staticmethod(set4)

    def getInstance(state):
        """getInstance(SoState state) -> SoCoordinateElement"""
        return _coin.SoCoordinateElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoCoordinateElement self) -> int32_t"""
        return _coin.SoCoordinateElement_getNum(self)


    def is3D(self):
        """is3D(SoCoordinateElement self) -> SbBool"""
        return _coin.SoCoordinateElement_is3D(self)


    def get3(self, index):
        """get3(SoCoordinateElement self, int const index) -> SbVec3f"""
        return _coin.SoCoordinateElement_get3(self, index)


    def get4(self, index):
        """get4(SoCoordinateElement self, int const index) -> SbVec4f"""
        return _coin.SoCoordinateElement_get4(self, index)


    def getArrayPtr3(self):
        """getArrayPtr3(SoCoordinateElement self) -> SbVec3f"""
        return _coin.SoCoordinateElement_getArrayPtr3(self)


    def getArrayPtr4(self):
        """getArrayPtr4(SoCoordinateElement 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, file):
        """output(SoCoordinateElement self, FILE * file)"""
        return _coin.SoCoordinateElement_output(self, file)

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(state, node, numCoords, coords):
    """SoCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
    return _coin.SoCoordinateElement_set3(state, node, numCoords, coords)

def SoCoordinateElement_set4(state, node, numCoords, coords):
    """SoCoordinateElement_set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
    return _coin.SoCoordinateElement_set4(state, node, numCoords, coords)

def SoCoordinateElement_getInstance(state):
    """SoCoordinateElement_getInstance(SoState state) -> SoCoordinateElement"""
    return _coin.SoCoordinateElement_getInstance(state)

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, state):
        """init(SoCreaseAngleElement self, SoState state)"""
        return _coin.SoCreaseAngleElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoCreaseAngleElement_set(*args)

    set = staticmethod(set)

    def get(*args):
        """
        get(SoState state) -> float
        get(SoState state, SbBool const isvrml1) -> float
        """
        return _coin.SoCreaseAngleElement_get(*args)

    get = staticmethod(get)

    def getDefault(*args):
        """
        getDefault() -> float
        getDefault(SbBool const 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 const complexity)
    SoCreaseAngleElement_set(SoState state, float const complexity)
    """
    return _coin.SoCreaseAngleElement_set(*args)

def SoCreaseAngleElement_get(*args):
    """
    get(SoState state) -> float
    SoCreaseAngleElement_get(SoState state, SbBool const isvrml1) -> float
    """
    return _coin.SoCreaseAngleElement_get(*args)

def SoCreaseAngleElement_getDefault(*args):
    """
    getDefault() -> float
    SoCreaseAngleElement_getDefault(SbBool const 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, state):
        """init(SoCullElement self, SoState state)"""
        return _coin.SoCullElement_init(self, state)


    def push(self, state):
        """push(SoCullElement self, SoState state)"""
        return _coin.SoCullElement_push(self, state)


    def setViewVolume(state, vv):
        """setViewVolume(SoState state, SbViewVolume vv)"""
        return _coin.SoCullElement_setViewVolume(state, vv)

    setViewVolume = staticmethod(setViewVolume)

    def addPlane(state, newplane):
        """addPlane(SoState state, SbPlane newplane)"""
        return _coin.SoCullElement_addPlane(state, newplane)

    addPlane = staticmethod(addPlane)

    def cullBox(state, box, transform=1):
        """
        cullBox(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool
        cullBox(SoState state, SbBox3f box) -> SbBool
        """
        return _coin.SoCullElement_cullBox(state, box, transform)

    cullBox = staticmethod(cullBox)

    def cullTest(state, box, transform=1):
        """
        cullTest(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool
        cullTest(SoState state, SbBox3f box) -> SbBool
        """
        return _coin.SoCullElement_cullTest(state, box, transform)

    cullTest = staticmethod(cullTest)

    def completelyInside(state):
        """completelyInside(SoState state) -> SbBool"""
        return _coin.SoCullElement_completelyInside(state)

    completelyInside = staticmethod(completelyInside)

    def matches(self, elt):
        """matches(SoCullElement self, SoElement elt) -> SbBool"""
        return _coin.SoCullElement_matches(self, elt)


    def copyMatchInfo(self):
        """copyMatchInfo(SoCullElement 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(state, vv):
    """SoCullElement_setViewVolume(SoState state, SbViewVolume vv)"""
    return _coin.SoCullElement_setViewVolume(state, vv)

def SoCullElement_addPlane(state, newplane):
    """SoCullElement_addPlane(SoState state, SbPlane newplane)"""
    return _coin.SoCullElement_addPlane(state, newplane)

def SoCullElement_cullBox(state, box, transform=1):
    """
    cullBox(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool
    SoCullElement_cullBox(SoState state, SbBox3f box) -> SbBool
    """
    return _coin.SoCullElement_cullBox(state, box, transform)

def SoCullElement_cullTest(state, box, transform=1):
    """
    cullTest(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool
    SoCullElement_cullTest(SoState state, SbBox3f box) -> SbBool
    """
    return _coin.SoCullElement_cullTest(state, box, transform)

def SoCullElement_completelyInside(state):
    """SoCullElement_completelyInside(SoState state) -> SbBool"""
    return _coin.SoCullElement_completelyInside(state)

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, state):
        """init(SoDecimationPercentageElement self, SoState state)"""
        return _coin.SoDecimationPercentageElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoDecimationPercentageElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> float"""
        return _coin.SoDecimationPercentageElement_get(state)

    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 const complexity)
    SoDecimationPercentageElement_set(SoState state, float const complexity)
    """
    return _coin.SoDecimationPercentageElement_set(*args)

def SoDecimationPercentageElement_get(state):
    """SoDecimationPercentageElement_get(SoState state) -> float"""
    return _coin.SoDecimationPercentageElement_get(state)

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, state):
        """init(SoDiffuseColorElement self, SoState state)"""
        return _coin.SoDiffuseColorElement_init(self, state)


    def set(state, node, numcolors, colors):
        """set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoDiffuseColorElement_set(state, node, numcolors, colors)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoDiffuseColorElement"""
        return _coin.SoDiffuseColorElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoDiffuseColorElement self) -> int32_t"""
        return _coin.SoDiffuseColorElement_getNum(self)


    def get(self, index):
        """get(SoDiffuseColorElement self, int const index) -> SbColor"""
        return _coin.SoDiffuseColorElement_get(self, index)


    def isPacked(self):
        """isPacked(SoDiffuseColorElement self) -> SbBool"""
        return _coin.SoDiffuseColorElement_isPacked(self)


    def hasPackedTransparency(self):
        """hasPackedTransparency(SoDiffuseColorElement self) -> SbBool"""
        return _coin.SoDiffuseColorElement_hasPackedTransparency(self)


    def getColorArrayPtr(self):
        """getColorArrayPtr(SoDiffuseColorElement self) -> SbColor"""
        return _coin.SoDiffuseColorElement_getColorArrayPtr(self)


    def getPackedArrayPtr(self):
        """getPackedArrayPtr(SoDiffuseColorElement self) -> uint32_t const *"""
        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(state, node, numcolors, colors):
    """SoDiffuseColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
    return _coin.SoDiffuseColorElement_set(state, node, numcolors, colors)

def SoDiffuseColorElement_getInstance(state):
    """SoDiffuseColorElement_getInstance(SoState state) -> SoDiffuseColorElement"""
    return _coin.SoDiffuseColorElement_getInstance(state)

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, state):
        """init(SoGLClipPlaneElement self, SoState state)"""
        return _coin.SoGLClipPlaneElement_init(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLClipPlaneElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLClipPlaneElement_pop(self, state, prevTopElement)


    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, state):
        """init(SoLightElement self, SoState state)"""
        return _coin.SoLightElement_init(self, state)


    def push(self, state):
        """push(SoLightElement self, SoState state)"""
        return _coin.SoLightElement_push(self, state)


    def add(state, light):
        """add(SoState state, SoLight light)"""
        return _coin.SoLightElement_add(state, light)

    add = staticmethod(add)

    def getLights(state):
        """getLights(SoState state) -> SoNodeList"""
        return _coin.SoLightElement_getLights(state)

    getLights = staticmethod(getLights)

    def getMatrix(state, index):
        """getMatrix(SoState state, int const index) -> SbMatrix"""
        return _coin.SoLightElement_getMatrix(state, index)

    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(state, light):
    """SoLightElement_add(SoState state, SoLight light)"""
    return _coin.SoLightElement_add(state, light)

def SoLightElement_getLights(state):
    """SoLightElement_getLights(SoState state) -> SoNodeList"""
    return _coin.SoLightElement_getLights(state)

def SoLightElement_getMatrix(state, index):
    """SoLightElement_getMatrix(SoState state, int const index) -> SbMatrix"""
    return _coin.SoLightElement_getMatrix(state, index)

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, state):
        """init(SoGLModelMatrixElement self, SoState state)"""
        return _coin.SoGLModelMatrixElement_init(self, state)


    def push(self, state):
        """push(SoGLModelMatrixElement self, SoState state)"""
        return _coin.SoGLModelMatrixElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLModelMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLModelMatrixElement_pop(self, state, prevTopElement)

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, state):
        """init(SoProfileElement self, SoState state)"""
        return _coin.SoProfileElement_init(self, state)


    def push(self, state):
        """push(SoProfileElement self, SoState state)"""
        return _coin.SoProfileElement_push(self, state)


    def add(state, profile):
        """add(SoState state, SoProfile profile)"""
        return _coin.SoProfileElement_add(state, profile)

    add = staticmethod(add)

    def get(state):
        """get(SoState state) -> SoNodeList"""
        return _coin.SoProfileElement_get(state)

    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(state, profile):
    """SoProfileElement_add(SoState state, SoProfile profile)"""
    return _coin.SoProfileElement_add(state, profile)

def SoProfileElement_get(state):
    """SoProfileElement_get(SoState state) -> SoNodeList"""
    return _coin.SoProfileElement_get(state)

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, state):
        """init(SoTextureMatrixElement self, SoState state)"""
        return _coin.SoTextureMatrixElement_init(self, state)


    def push(self, state):
        """push(SoTextureMatrixElement self, SoState state)"""
        return _coin.SoTextureMatrixElement_push(self, state)


    def makeIdentity(state, node):
        """makeIdentity(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_makeIdentity(state, node)

    makeIdentity = staticmethod(makeIdentity)

    def set(state, node):
        """set(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_set(state, node)

    set = staticmethod(set)

    def mult(state, node):
        """mult(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_mult(state, node)

    mult = staticmethod(mult)

    def translateBy(state, node, translation):
        """translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoTextureMatrixElement_translateBy(state, node, translation)

    translateBy = staticmethod(translateBy)

    def rotateBy(state, node, rotation):
        """rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoTextureMatrixElement_rotateBy(state, node, rotation)

    rotateBy = staticmethod(rotateBy)

    def scaleBy(state, node, scaleFactor):
        """scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoTextureMatrixElement_scaleBy(state, node, scaleFactor)

    scaleBy = staticmethod(scaleBy)

    def get(state):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoTextureMatrixElement_get(state)

    get = staticmethod(get)

    def emptyMatrix(state):
        """emptyMatrix(SoState state)"""
        return _coin.SoTextureMatrixElement_emptyMatrix(state)

    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(state, node):
    """SoTextureMatrixElement_makeIdentity(SoState state, SoNode node)"""
    return _coin.SoTextureMatrixElement_makeIdentity(state, node)

def SoTextureMatrixElement_set(state, node):
    """SoTextureMatrixElement_set(SoState state, SoNode node)"""
    return _coin.SoTextureMatrixElement_set(state, node)

def SoTextureMatrixElement_mult(state, node):
    """SoTextureMatrixElement_mult(SoState state, SoNode node)"""
    return _coin.SoTextureMatrixElement_mult(state, node)

def SoTextureMatrixElement_translateBy(state, node, translation):
    """SoTextureMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
    return _coin.SoTextureMatrixElement_translateBy(state, node, translation)

def SoTextureMatrixElement_rotateBy(state, node, rotation):
    """SoTextureMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
    return _coin.SoTextureMatrixElement_rotateBy(state, node, rotation)

def SoTextureMatrixElement_scaleBy(state, node, scaleFactor):
    """SoTextureMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
    return _coin.SoTextureMatrixElement_scaleBy(state, node, scaleFactor)

def SoTextureMatrixElement_get(state):
    """SoTextureMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoTextureMatrixElement_get(state)

def SoTextureMatrixElement_emptyMatrix(state):
    """SoTextureMatrixElement_emptyMatrix(SoState state)"""
    return _coin.SoTextureMatrixElement_emptyMatrix(state)

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, state):
        """init(SoGLTextureMatrixElement self, SoState state)"""
        return _coin.SoGLTextureMatrixElement_init(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLTextureMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureMatrixElement_pop(self, state, prevTopElement)


    def setEltIdentity():
        """setEltIdentity()"""
        return _coin.SoGLTextureMatrixElement_setEltIdentity()

    setEltIdentity = staticmethod(setEltIdentity)

    def setElt(self):
        """setElt(SoGLTextureMatrixElement self)"""
        return _coin.SoGLTextureMatrixElement_setElt(self)


    def makeEltIdentity(self):
        """makeEltIdentity(SoGLTextureMatrixElement self)"""
        return _coin.SoGLTextureMatrixElement_makeEltIdentity(self)


    def multElt(self):
        """multElt(SoGLTextureMatrixElement self)"""
        return _coin.SoGLTextureMatrixElement_multElt(self)


    def translateEltBy(self, translation):
        """translateEltBy(SoGLTextureMatrixElement self, SbVec3f translation)"""
        return _coin.SoGLTextureMatrixElement_translateEltBy(self, translation)


    def rotateEltBy(self, translation):
        """rotateEltBy(SoGLTextureMatrixElement self, SbRotation translation)"""
        return _coin.SoGLTextureMatrixElement_rotateEltBy(self, translation)


    def scaleEltBy(self, scaleFactor):
        """scaleEltBy(SoGLTextureMatrixElement self, SbVec3f scaleFactor)"""
        return _coin.SoGLTextureMatrixElement_scaleEltBy(self, scaleFactor)

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, state):
        """init(SoGLDrawStyleElement self, SoState state)"""
        return _coin.SoGLDrawStyleElement_init(self, state)


    def push(self, state):
        """push(SoGLDrawStyleElement self, SoState state)"""
        return _coin.SoGLDrawStyleElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLDrawStyleElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLDrawStyleElement_pop(self, state, prevTopElement)

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, state):
        """init(SoGLLightIdElement self, SoState state)"""
        return _coin.SoGLLightIdElement_init(self, state)


    def push(self, state):
        """push(SoGLLightIdElement self, SoState state)"""
        return _coin.SoGLLightIdElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLLightIdElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLightIdElement_pop(self, state, prevTopElement)


    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(state):
        """get(SoState state) -> int32_t"""
        return _coin.SoGLLightIdElement_get(state)

    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(state):
    """SoGLLightIdElement_get(SoState state) -> int32_t"""
    return _coin.SoGLLightIdElement_get(state)

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, state):
        """init(SoTextureEnabledElement self, SoState state)"""
        return _coin.SoTextureEnabledElement_init(self, state)


    def set(state, node, enabled):
        """set(SoState state, SoNode node, SbBool const enabled)"""
        return _coin.SoTextureEnabledElement_set(state, node, enabled)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbBool"""
        return _coin.SoTextureEnabledElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoTextureEnabledElement_getDefault()

    getDefault = staticmethod(getDefault)

    def setElt(self, value):
        """setElt(SoTextureEnabledElement self, int32_t value)"""
        return _coin.SoTextureEnabledElement_setElt(self, value)

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(state, node, enabled):
    """SoTextureEnabledElement_set(SoState state, SoNode node, SbBool const enabled)"""
    return _coin.SoTextureEnabledElement_set(state, node, enabled)

def SoTextureEnabledElement_get(state):
    """SoTextureEnabledElement_get(SoState state) -> SbBool"""
    return _coin.SoTextureEnabledElement_get(state)

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, state):
        """init(SoGLTextureEnabledElement self, SoState state)"""
        return _coin.SoGLTextureEnabledElement_init(self, state)


    def push(self, state):
        """push(SoGLTextureEnabledElement self, SoState state)"""
        return _coin.SoGLTextureEnabledElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLTextureEnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureEnabledElement_pop(self, state, prevTopElement)


    def set(*args):
        """
        set(SoState state, SoNode node, SbBool const enabled)
        set(SoState state, SbBool const enabled)
        """
        return _coin.SoGLTextureEnabledElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbBool"""
        return _coin.SoGLTextureEnabledElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoGLTextureEnabledElement_getDefault()

    getDefault = staticmethod(getDefault)

    def setElt(self, value):
        """setElt(SoGLTextureEnabledElement self, int32_t value)"""
        return _coin.SoGLTextureEnabledElement_setElt(self, value)


    def enableRectangle(state, node):
        """enableRectangle(SoState state, SoNode node)"""
        return _coin.SoGLTextureEnabledElement_enableRectangle(state, node)

    enableRectangle = staticmethod(enableRectangle)

    def enableCubeMap(state, node):
        """enableCubeMap(SoState state, SoNode node)"""
        return _coin.SoGLTextureEnabledElement_enableCubeMap(state, node)

    enableCubeMap = staticmethod(enableCubeMap)

    def getMode(state):
        """getMode(SoState state) -> SoGLTextureEnabledElement::Mode"""
        return _coin.SoGLTextureEnabledElement_getMode(state)

    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 const enabled)
    SoGLTextureEnabledElement_set(SoState state, SbBool const enabled)
    """
    return _coin.SoGLTextureEnabledElement_set(*args)

def SoGLTextureEnabledElement_get(state):
    """SoGLTextureEnabledElement_get(SoState state) -> SbBool"""
    return _coin.SoGLTextureEnabledElement_get(state)

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

def SoGLTextureEnabledElement_enableRectangle(state, node):
    """SoGLTextureEnabledElement_enableRectangle(SoState state, SoNode node)"""
    return _coin.SoGLTextureEnabledElement_enableRectangle(state, node)

def SoGLTextureEnabledElement_enableCubeMap(state, node):
    """SoGLTextureEnabledElement_enableCubeMap(SoState state, SoNode node)"""
    return _coin.SoGLTextureEnabledElement_enableCubeMap(state, node)

def SoGLTextureEnabledElement_getMode(state):
    """SoGLTextureEnabledElement_getMode(SoState state) -> SoGLTextureEnabledElement::Mode"""
    return _coin.SoGLTextureEnabledElement_getMode(state)

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, state):
        """init(SoTexture3EnabledElement self, SoState state)"""
        return _coin.SoTexture3EnabledElement_init(self, state)


    def set(state, node, enabled):
        """set(SoState state, SoNode node, SbBool const enabled)"""
        return _coin.SoTexture3EnabledElement_set(state, node, enabled)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbBool"""
        return _coin.SoTexture3EnabledElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoTexture3EnabledElement_getDefault()

    getDefault = staticmethod(getDefault)

    def setElt(self, value):
        """setElt(SoTexture3EnabledElement self, int32_t value)"""
        return _coin.SoTexture3EnabledElement_setElt(self, value)

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(state, node, enabled):
    """SoTexture3EnabledElement_set(SoState state, SoNode node, SbBool const enabled)"""
    return _coin.SoTexture3EnabledElement_set(state, node, enabled)

def SoTexture3EnabledElement_get(state):
    """SoTexture3EnabledElement_get(SoState state) -> SbBool"""
    return _coin.SoTexture3EnabledElement_get(state)

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, state):
        """init(SoGLTexture3EnabledElement self, SoState state)"""
        return _coin.SoGLTexture3EnabledElement_init(self, state)


    def push(self, state):
        """push(SoGLTexture3EnabledElement self, SoState state)"""
        return _coin.SoGLTexture3EnabledElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLTexture3EnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTexture3EnabledElement_pop(self, state, prevTopElement)


    def set(*args):
        """
        set(SoState state, SoNode node, SbBool const enabled)
        set(SoState state, SbBool const enabled)
        """
        return _coin.SoGLTexture3EnabledElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbBool"""
        return _coin.SoGLTexture3EnabledElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SbBool"""
        return _coin.SoGLTexture3EnabledElement_getDefault()

    getDefault = staticmethod(getDefault)

    def setElt(self, value):
        """setElt(SoGLTexture3EnabledElement self, int32_t value)"""
        return _coin.SoGLTexture3EnabledElement_setElt(self, value)

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 const enabled)
    SoGLTexture3EnabledElement_set(SoState state, SbBool const enabled)
    """
    return _coin.SoGLTexture3EnabledElement_set(*args)

def SoGLTexture3EnabledElement_get(state):
    """SoGLTexture3EnabledElement_get(SoState state) -> SbBool"""
    return _coin.SoGLTexture3EnabledElement_get(state)

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, state):
        """init(SoLinePatternElement self, SoState state)"""
        return _coin.SoLinePatternElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, int32_t const pattern)
        set(SoState state, int32_t const pattern)
        """
        return _coin.SoLinePatternElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> int32_t"""
        return _coin.SoLinePatternElement_get(state)

    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 const pattern)
    SoLinePatternElement_set(SoState state, int32_t const pattern)
    """
    return _coin.SoLinePatternElement_set(*args)

def SoLinePatternElement_get(state):
    """SoLinePatternElement_get(SoState state) -> int32_t"""
    return _coin.SoLinePatternElement_get(state)

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, state):
        """init(SoGLLinePatternElement self, SoState state)"""
        return _coin.SoGLLinePatternElement_init(self, state)


    def push(self, state):
        """push(SoGLLinePatternElement self, SoState state)"""
        return _coin.SoGLLinePatternElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLLinePatternElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLinePatternElement_pop(self, state, prevTopElement)

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, state):
        """init(SoSwitchElement self, SoState state)"""
        return _coin.SoSwitchElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, int32_t const index)
        set(SoState state, int32_t const index)
        """
        return _coin.SoSwitchElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> int32_t"""
        return _coin.SoSwitchElement_get(state)

    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 const index)
    SoSwitchElement_set(SoState state, int32_t const index)
    """
    return _coin.SoSwitchElement_set(*args)

def SoSwitchElement_get(state):
    """SoSwitchElement_get(SoState state) -> int32_t"""
    return _coin.SoSwitchElement_get(state)

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, state):
        """init(SoTextOutlineEnabledElement self, SoState state)"""
        return _coin.SoTextOutlineEnabledElement_init(self, state)


    def push(self, state):
        """push(SoTextOutlineEnabledElement self, SoState state)"""
        return _coin.SoTextOutlineEnabledElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoTextOutlineEnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoTextOutlineEnabledElement_pop(self, state, prevTopElement)


    def set(*args):
        """
        set(SoState state, SoNode node, SbBool const enabled)
        set(SoState state, SbBool const enabled)
        """
        return _coin.SoTextOutlineEnabledElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbBool"""
        return _coin.SoTextOutlineEnabledElement_get(state)

    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 const enabled)
    SoTextOutlineEnabledElement_set(SoState state, SbBool const enabled)
    """
    return _coin.SoTextOutlineEnabledElement_set(*args)

def SoTextOutlineEnabledElement_get(state):
    """SoTextOutlineEnabledElement_get(SoState state) -> SbBool"""
    return _coin.SoTextOutlineEnabledElement_get(state)

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, state):
        """init(SoUnitsElement self, SoState state)"""
        return _coin.SoUnitsElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, SoUnitsElement::Units const units)
        set(SoState state, SoUnitsElement::Units const units)
        """
        return _coin.SoUnitsElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoUnitsElement::Units"""
        return _coin.SoUnitsElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoUnitsElement::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, SoUnitsElement::Units const units)
    SoUnitsElement_set(SoState state, SoUnitsElement::Units const units)
    """
    return _coin.SoUnitsElement_set(*args)

def SoUnitsElement_get(state):
    """SoUnitsElement_get(SoState state) -> SoUnitsElement::Units"""
    return _coin.SoUnitsElement_get(state)

def SoUnitsElement_getDefault():
    """SoUnitsElement_getDefault() -> SoUnitsElement::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, state):
        """init(SoFocalDistanceElement self, SoState state)"""
        return _coin.SoFocalDistanceElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const distance)
        set(SoState state, float const distance)
        """
        return _coin.SoFocalDistanceElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> float"""
        return _coin.SoFocalDistanceElement_get(state)

    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 const distance)
    SoFocalDistanceElement_set(SoState state, float const distance)
    """
    return _coin.SoFocalDistanceElement_set(*args)

def SoFocalDistanceElement_get(state):
    """SoFocalDistanceElement_get(SoState state) -> float"""
    return _coin.SoFocalDistanceElement_get(state)

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, state):
        """init(SoFontSizeElement self, SoState state)"""
        return _coin.SoFontSizeElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const fontSize)
        set(SoState state, float const fontSize)
        """
        return _coin.SoFontSizeElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> float"""
        return _coin.SoFontSizeElement_get(state)

    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 const fontSize)
    SoFontSizeElement_set(SoState state, float const fontSize)
    """
    return _coin.SoFontSizeElement_set(*args)

def SoFontSizeElement_get(state):
    """SoFontSizeElement_get(SoState state) -> float"""
    return _coin.SoFontSizeElement_get(state)

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, state):
        """init(SoLineWidthElement self, SoState state)"""
        return _coin.SoLineWidthElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const lineWidth)
        set(SoState state, float const lineWidth)
        """
        return _coin.SoLineWidthElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> float"""
        return _coin.SoLineWidthElement_get(state)

    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 const lineWidth)
    SoLineWidthElement_set(SoState state, float const lineWidth)
    """
    return _coin.SoLineWidthElement_set(*args)

def SoLineWidthElement_get(state):
    """SoLineWidthElement_get(SoState state) -> float"""
    return _coin.SoLineWidthElement_get(state)

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, state):
        """init(SoGLLineWidthElement self, SoState state)"""
        return _coin.SoGLLineWidthElement_init(self, state)


    def push(self, state):
        """push(SoGLLineWidthElement self, SoState state)"""
        return _coin.SoGLLineWidthElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLLineWidthElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLineWidthElement_pop(self, state, prevTopElement)

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, state):
        """init(SoPointSizeElement self, SoState state)"""
        return _coin.SoPointSizeElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const pointSize)
        set(SoState state, float const pointSize)
        """
        return _coin.SoPointSizeElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> float"""
        return _coin.SoPointSizeElement_get(state)

    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 const pointSize)
    SoPointSizeElement_set(SoState state, float const pointSize)
    """
    return _coin.SoPointSizeElement_set(*args)

def SoPointSizeElement_get(state):
    """SoPointSizeElement_get(SoState state) -> float"""
    return _coin.SoPointSizeElement_get(state)

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, state):
        """init(SoGLPointSizeElement self, SoState state)"""
        return _coin.SoGLPointSizeElement_init(self, state)


    def push(self, state):
        """push(SoGLPointSizeElement self, SoState state)"""
        return _coin.SoGLPointSizeElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLPointSizeElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLPointSizeElement_pop(self, state, prevTopElement)

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, state):
        """init(SoTextureQualityElement self, SoState state)"""
        return _coin.SoTextureQualityElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const quality)
        set(SoState state, float const quality)
        """
        return _coin.SoTextureQualityElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> float"""
        return _coin.SoTextureQualityElement_get(state)

    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 const quality)
    SoTextureQualityElement_set(SoState state, float const quality)
    """
    return _coin.SoTextureQualityElement_set(*args)

def SoTextureQualityElement_get(state):
    """SoTextureQualityElement_get(SoState state) -> float"""
    return _coin.SoTextureQualityElement_get(state)

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, element):
        """matches(SoTextureOverrideElement self, SoElement element) -> SbBool"""
        return _coin.SoTextureOverrideElement_matches(self, element)


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


    def init(self, state):
        """init(SoTextureOverrideElement self, SoState state)"""
        return _coin.SoTextureOverrideElement_init(self, state)


    def push(self, state):
        """push(SoTextureOverrideElement self, SoState state)"""
        return _coin.SoTextureOverrideElement_push(self, state)


    def getQualityOverride(state):
        """getQualityOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getQualityOverride(state)

    getQualityOverride = staticmethod(getQualityOverride)

    def getImageOverride(state):
        """getImageOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getImageOverride(state)

    getImageOverride = staticmethod(getImageOverride)

    def getBumpMapOverride(state):
        """getBumpMapOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getBumpMapOverride(state)

    getBumpMapOverride = staticmethod(getBumpMapOverride)

    def setQualityOverride(state, value):
        """setQualityOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setQualityOverride(state, value)

    setQualityOverride = staticmethod(setQualityOverride)

    def setImageOverride(state, value):
        """setImageOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setImageOverride(state, value)

    setImageOverride = staticmethod(setImageOverride)

    def setBumpMapOverride(state, value):
        """setBumpMapOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setBumpMapOverride(state, value)

    setBumpMapOverride = staticmethod(setBumpMapOverride)

    def output(self, fp):
        """output(SoTextureOverrideElement self, FILE * fp)"""
        return _coin.SoTextureOverrideElement_output(self, fp)

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(state):
    """SoTextureOverrideElement_getQualityOverride(SoState state) -> SbBool"""
    return _coin.SoTextureOverrideElement_getQualityOverride(state)

def SoTextureOverrideElement_getImageOverride(state):
    """SoTextureOverrideElement_getImageOverride(SoState state) -> SbBool"""
    return _coin.SoTextureOverrideElement_getImageOverride(state)

def SoTextureOverrideElement_getBumpMapOverride(state):
    """SoTextureOverrideElement_getBumpMapOverride(SoState state) -> SbBool"""
    return _coin.SoTextureOverrideElement_getBumpMapOverride(state)

def SoTextureOverrideElement_setQualityOverride(state, value):
    """SoTextureOverrideElement_setQualityOverride(SoState state, SbBool const value)"""
    return _coin.SoTextureOverrideElement_setQualityOverride(state, value)

def SoTextureOverrideElement_setImageOverride(state, value):
    """SoTextureOverrideElement_setImageOverride(SoState state, SbBool const value)"""
    return _coin.SoTextureOverrideElement_setImageOverride(state, value)

def SoTextureOverrideElement_setBumpMapOverride(state, value):
    """SoTextureOverrideElement_setBumpMapOverride(SoState state, SbBool const value)"""
    return _coin.SoTextureOverrideElement_setBumpMapOverride(state, value)

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, state):
        """init(SoGLRenderPassElement self, SoState state)"""
        return _coin.SoGLRenderPassElement_init(self, state)


    def matches(self, element):
        """matches(SoGLRenderPassElement self, SoElement element) -> SbBool"""
        return _coin.SoGLRenderPassElement_matches(self, element)


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


    def set(state, passNumber):
        """set(SoState state, int const passNumber)"""
        return _coin.SoGLRenderPassElement_set(state, passNumber)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> int"""
        return _coin.SoGLRenderPassElement_get(state)

    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(state, passNumber):
    """SoGLRenderPassElement_set(SoState state, int const passNumber)"""
    return _coin.SoGLRenderPassElement_set(state, passNumber)

def SoGLRenderPassElement_get(state):
    """SoGLRenderPassElement_get(SoState state) -> int"""
    return _coin.SoGLRenderPassElement_get(state)

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, state):
        """init(SoGLUpdateAreaElement self, SoState state)"""
        return _coin.SoGLUpdateAreaElement_init(self, state)


    def push(self, state):
        """push(SoGLUpdateAreaElement self, SoState state)"""
        return _coin.SoGLUpdateAreaElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLUpdateAreaElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLUpdateAreaElement_pop(self, state, prevTopElement)


    def matches(self, element):
        """matches(SoGLUpdateAreaElement self, SoElement element) -> SbBool"""
        return _coin.SoGLUpdateAreaElement_matches(self, element)


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


    def set(state, origin, size):
        """set(SoState state, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLUpdateAreaElement_set(state, origin, size)

    set = staticmethod(set)

    def get(state, origin, size):
        """get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
        return _coin.SoGLUpdateAreaElement_get(state, origin, size)

    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(state, origin, size):
    """SoGLUpdateAreaElement_set(SoState state, SbVec2f origin, SbVec2f size)"""
    return _coin.SoGLUpdateAreaElement_set(state, origin, size)

def SoGLUpdateAreaElement_get(state, origin, size):
    """SoGLUpdateAreaElement_get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
    return _coin.SoGLUpdateAreaElement_get(state, origin, size)

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, state):
        """init(SoLocalBBoxMatrixElement self, SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_init(self, state)


    def push(self, state):
        """push(SoLocalBBoxMatrixElement self, SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_push(self, state)


    def makeIdentity(state):
        """makeIdentity(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_makeIdentity(state)

    makeIdentity = staticmethod(makeIdentity)

    def set(state):
        """set(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_set(state)

    set = staticmethod(set)

    def mult(state):
        """mult(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_mult(state)

    mult = staticmethod(mult)

    def translateBy(state, translation):
        """translateBy(SoState state, SbVec3f translation)"""
        return _coin.SoLocalBBoxMatrixElement_translateBy(state, translation)

    translateBy = staticmethod(translateBy)

    def rotateBy(state, rotation):
        """rotateBy(SoState state, SbRotation rotation)"""
        return _coin.SoLocalBBoxMatrixElement_rotateBy(state, rotation)

    rotateBy = staticmethod(rotateBy)

    def scaleBy(state, scaleFactor):
        """scaleBy(SoState state, SbVec3f scaleFactor)"""
        return _coin.SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor)

    scaleBy = staticmethod(scaleBy)

    def pushMatrix(state):
        """pushMatrix(SoState state) -> SbMatrix"""
        return _coin.SoLocalBBoxMatrixElement_pushMatrix(state)

    pushMatrix = staticmethod(pushMatrix)

    def popMatrix(state):
        """popMatrix(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_popMatrix(state)

    popMatrix = staticmethod(popMatrix)

    def resetAll(state):
        """resetAll(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_resetAll(state)

    resetAll = staticmethod(resetAll)

    def get(state):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoLocalBBoxMatrixElement_get(state)

    get = staticmethod(get)

    def matches(self, element):
        """matches(SoLocalBBoxMatrixElement self, SoElement element) -> SbBool"""
        return _coin.SoLocalBBoxMatrixElement_matches(self, element)


    def copyMatchInfo(self):
        """copyMatchInfo(SoLocalBBoxMatrixElement 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(state):
    """SoLocalBBoxMatrixElement_makeIdentity(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_makeIdentity(state)

def SoLocalBBoxMatrixElement_set(state):
    """SoLocalBBoxMatrixElement_set(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_set(state)

def SoLocalBBoxMatrixElement_mult(state):
    """SoLocalBBoxMatrixElement_mult(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_mult(state)

def SoLocalBBoxMatrixElement_translateBy(state, translation):
    """SoLocalBBoxMatrixElement_translateBy(SoState state, SbVec3f translation)"""
    return _coin.SoLocalBBoxMatrixElement_translateBy(state, translation)

def SoLocalBBoxMatrixElement_rotateBy(state, rotation):
    """SoLocalBBoxMatrixElement_rotateBy(SoState state, SbRotation rotation)"""
    return _coin.SoLocalBBoxMatrixElement_rotateBy(state, rotation)

def SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor):
    """SoLocalBBoxMatrixElement_scaleBy(SoState state, SbVec3f scaleFactor)"""
    return _coin.SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor)

def SoLocalBBoxMatrixElement_pushMatrix(state):
    """SoLocalBBoxMatrixElement_pushMatrix(SoState state) -> SbMatrix"""
    return _coin.SoLocalBBoxMatrixElement_pushMatrix(state)

def SoLocalBBoxMatrixElement_popMatrix(state):
    """SoLocalBBoxMatrixElement_popMatrix(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_popMatrix(state)

def SoLocalBBoxMatrixElement_resetAll(state):
    """SoLocalBBoxMatrixElement_resetAll(SoState state)"""
    return _coin.SoLocalBBoxMatrixElement_resetAll(state)

def SoLocalBBoxMatrixElement_get(state):
    """SoLocalBBoxMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoLocalBBoxMatrixElement_get(state)

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, state):
        """init(SoOverrideElement self, SoState state)"""
        return _coin.SoOverrideElement_init(self, state)


    def push(self, state):
        """push(SoOverrideElement self, SoState state)"""
        return _coin.SoOverrideElement_push(self, state)


    def matches(self, element):
        """matches(SoOverrideElement self, SoElement element) -> SbBool"""
        return _coin.SoOverrideElement_matches(self, element)


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


    def getFlags(state):
        """getFlags(SoState state) -> uint32_t"""
        return _coin.SoOverrideElement_getFlags(state)

    getFlags = staticmethod(getFlags)

    def getAmbientColorOverride(state):
        """getAmbientColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getAmbientColorOverride(state)

    getAmbientColorOverride = staticmethod(getAmbientColorOverride)

    def getColorIndexOverride(state):
        """getColorIndexOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getColorIndexOverride(state)

    getColorIndexOverride = staticmethod(getColorIndexOverride)

    def getComplexityOverride(state):
        """getComplexityOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getComplexityOverride(state)

    getComplexityOverride = staticmethod(getComplexityOverride)

    def getComplexityTypeOverride(state):
        """getComplexityTypeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getComplexityTypeOverride(state)

    getComplexityTypeOverride = staticmethod(getComplexityTypeOverride)

    def getCreaseAngleOverride(state):
        """getCreaseAngleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getCreaseAngleOverride(state)

    getCreaseAngleOverride = staticmethod(getCreaseAngleOverride)

    def getDiffuseColorOverride(state):
        """getDiffuseColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getDiffuseColorOverride(state)

    getDiffuseColorOverride = staticmethod(getDiffuseColorOverride)

    def getDrawStyleOverride(state):
        """getDrawStyleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getDrawStyleOverride(state)

    getDrawStyleOverride = staticmethod(getDrawStyleOverride)

    def getEmissiveColorOverride(state):
        """getEmissiveColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getEmissiveColorOverride(state)

    getEmissiveColorOverride = staticmethod(getEmissiveColorOverride)

    def getFontNameOverride(state):
        """getFontNameOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getFontNameOverride(state)

    getFontNameOverride = staticmethod(getFontNameOverride)

    def getFontSizeOverride(state):
        """getFontSizeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getFontSizeOverride(state)

    getFontSizeOverride = staticmethod(getFontSizeOverride)

    def getLightModelOverride(state):
        """getLightModelOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLightModelOverride(state)

    getLightModelOverride = staticmethod(getLightModelOverride)

    def getLinePatternOverride(state):
        """getLinePatternOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLinePatternOverride(state)

    getLinePatternOverride = staticmethod(getLinePatternOverride)

    def getLineWidthOverride(state):
        """getLineWidthOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLineWidthOverride(state)

    getLineWidthOverride = staticmethod(getLineWidthOverride)

    def getMaterialBindingOverride(state):
        """getMaterialBindingOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getMaterialBindingOverride(state)

    getMaterialBindingOverride = staticmethod(getMaterialBindingOverride)

    def getPickStyleOverride(state):
        """getPickStyleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPickStyleOverride(state)

    getPickStyleOverride = staticmethod(getPickStyleOverride)

    def getPointSizeOverride(state):
        """getPointSizeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPointSizeOverride(state)

    getPointSizeOverride = staticmethod(getPointSizeOverride)

    def getPolygonOffsetOverride(state):
        """getPolygonOffsetOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPolygonOffsetOverride(state)

    getPolygonOffsetOverride = staticmethod(getPolygonOffsetOverride)

    def getShapeHintsOverride(state):
        """getShapeHintsOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getShapeHintsOverride(state)

    getShapeHintsOverride = staticmethod(getShapeHintsOverride)

    def getShininessOverride(state):
        """getShininessOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getShininessOverride(state)

    getShininessOverride = staticmethod(getShininessOverride)

    def getSpecularColorOverride(state):
        """getSpecularColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getSpecularColorOverride(state)

    getSpecularColorOverride = staticmethod(getSpecularColorOverride)

    def getTransparencyOverride(state):
        """getTransparencyOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getTransparencyOverride(state)

    getTransparencyOverride = staticmethod(getTransparencyOverride)

    def getTransparencyTypeOverride(state):
        """getTransparencyTypeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getTransparencyTypeOverride(state)

    getTransparencyTypeOverride = staticmethod(getTransparencyTypeOverride)

    def getNormalVectorOverride(state):
        """getNormalVectorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getNormalVectorOverride(state)

    getNormalVectorOverride = staticmethod(getNormalVectorOverride)

    def getNormalBindingOverride(state):
        """getNormalBindingOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getNormalBindingOverride(state)

    getNormalBindingOverride = staticmethod(getNormalBindingOverride)

    def setAmbientColorOverride(state, node, override):
        """setAmbientColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setAmbientColorOverride(state, node, override)

    setAmbientColorOverride = staticmethod(setAmbientColorOverride)

    def setColorIndexOverride(state, node, override):
        """setColorIndexOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setColorIndexOverride(state, node, override)

    setColorIndexOverride = staticmethod(setColorIndexOverride)

    def setComplexityOverride(state, node, override):
        """setComplexityOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setComplexityOverride(state, node, override)

    setComplexityOverride = staticmethod(setComplexityOverride)

    def setComplexityTypeOverride(state, node, override):
        """setComplexityTypeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setComplexityTypeOverride(state, node, override)

    setComplexityTypeOverride = staticmethod(setComplexityTypeOverride)

    def setCreaseAngleOverride(state, node, override):
        """setCreaseAngleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setCreaseAngleOverride(state, node, override)

    setCreaseAngleOverride = staticmethod(setCreaseAngleOverride)

    def setDiffuseColorOverride(state, node, override):
        """setDiffuseColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setDiffuseColorOverride(state, node, override)

    setDiffuseColorOverride = staticmethod(setDiffuseColorOverride)

    def setDrawStyleOverride(state, node, override):
        """setDrawStyleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setDrawStyleOverride(state, node, override)

    setDrawStyleOverride = staticmethod(setDrawStyleOverride)

    def setEmissiveColorOverride(state, node, override):
        """setEmissiveColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setEmissiveColorOverride(state, node, override)

    setEmissiveColorOverride = staticmethod(setEmissiveColorOverride)

    def setFontNameOverride(state, node, override):
        """setFontNameOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setFontNameOverride(state, node, override)

    setFontNameOverride = staticmethod(setFontNameOverride)

    def setFontSizeOverride(state, node, override):
        """setFontSizeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setFontSizeOverride(state, node, override)

    setFontSizeOverride = staticmethod(setFontSizeOverride)

    def setLightModelOverride(state, node, override):
        """setLightModelOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLightModelOverride(state, node, override)

    setLightModelOverride = staticmethod(setLightModelOverride)

    def setLinePatternOverride(state, node, override):
        """setLinePatternOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLinePatternOverride(state, node, override)

    setLinePatternOverride = staticmethod(setLinePatternOverride)

    def setLineWidthOverride(state, node, override):
        """setLineWidthOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLineWidthOverride(state, node, override)

    setLineWidthOverride = staticmethod(setLineWidthOverride)

    def setMaterialBindingOverride(state, node, override):
        """setMaterialBindingOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setMaterialBindingOverride(state, node, override)

    setMaterialBindingOverride = staticmethod(setMaterialBindingOverride)

    def setPickStyleOverride(state, node, override):
        """setPickStyleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPickStyleOverride(state, node, override)

    setPickStyleOverride = staticmethod(setPickStyleOverride)

    def setPointSizeOverride(state, node, override):
        """setPointSizeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPointSizeOverride(state, node, override)

    setPointSizeOverride = staticmethod(setPointSizeOverride)

    def setPolygonOffsetOverride(state, node, override):
        """setPolygonOffsetOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPolygonOffsetOverride(state, node, override)

    setPolygonOffsetOverride = staticmethod(setPolygonOffsetOverride)

    def setShapeHintsOverride(state, node, override):
        """setShapeHintsOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setShapeHintsOverride(state, node, override)

    setShapeHintsOverride = staticmethod(setShapeHintsOverride)

    def setShininessOverride(state, node, override):
        """setShininessOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setShininessOverride(state, node, override)

    setShininessOverride = staticmethod(setShininessOverride)

    def setSpecularColorOverride(state, node, override):
        """setSpecularColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setSpecularColorOverride(state, node, override)

    setSpecularColorOverride = staticmethod(setSpecularColorOverride)

    def setTransparencyOverride(state, node, override):
        """setTransparencyOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setTransparencyOverride(state, node, override)

    setTransparencyOverride = staticmethod(setTransparencyOverride)

    def setTransparencyTypeOverride(state, node, override):
        """setTransparencyTypeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setTransparencyTypeOverride(state, node, override)

    setTransparencyTypeOverride = staticmethod(setTransparencyTypeOverride)

    def setNormalVectorOverride(state, node, override):
        """setNormalVectorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setNormalVectorOverride(state, node, override)

    setNormalVectorOverride = staticmethod(setNormalVectorOverride)

    def setNormalBindingOverride(state, node, override):
        """setNormalBindingOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setNormalBindingOverride(state, node, override)

    setNormalBindingOverride = staticmethod(setNormalBindingOverride)

    def output(self, file):
        """output(SoOverrideElement self, FILE * file)"""
        return _coin.SoOverrideElement_output(self, file)

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(state):
    """SoOverrideElement_getFlags(SoState state) -> uint32_t"""
    return _coin.SoOverrideElement_getFlags(state)

def SoOverrideElement_getAmbientColorOverride(state):
    """SoOverrideElement_getAmbientColorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getAmbientColorOverride(state)

def SoOverrideElement_getColorIndexOverride(state):
    """SoOverrideElement_getColorIndexOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getColorIndexOverride(state)

def SoOverrideElement_getComplexityOverride(state):
    """SoOverrideElement_getComplexityOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getComplexityOverride(state)

def SoOverrideElement_getComplexityTypeOverride(state):
    """SoOverrideElement_getComplexityTypeOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getComplexityTypeOverride(state)

def SoOverrideElement_getCreaseAngleOverride(state):
    """SoOverrideElement_getCreaseAngleOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getCreaseAngleOverride(state)

def SoOverrideElement_getDiffuseColorOverride(state):
    """SoOverrideElement_getDiffuseColorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getDiffuseColorOverride(state)

def SoOverrideElement_getDrawStyleOverride(state):
    """SoOverrideElement_getDrawStyleOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getDrawStyleOverride(state)

def SoOverrideElement_getEmissiveColorOverride(state):
    """SoOverrideElement_getEmissiveColorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getEmissiveColorOverride(state)

def SoOverrideElement_getFontNameOverride(state):
    """SoOverrideElement_getFontNameOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getFontNameOverride(state)

def SoOverrideElement_getFontSizeOverride(state):
    """SoOverrideElement_getFontSizeOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getFontSizeOverride(state)

def SoOverrideElement_getLightModelOverride(state):
    """SoOverrideElement_getLightModelOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getLightModelOverride(state)

def SoOverrideElement_getLinePatternOverride(state):
    """SoOverrideElement_getLinePatternOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getLinePatternOverride(state)

def SoOverrideElement_getLineWidthOverride(state):
    """SoOverrideElement_getLineWidthOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getLineWidthOverride(state)

def SoOverrideElement_getMaterialBindingOverride(state):
    """SoOverrideElement_getMaterialBindingOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getMaterialBindingOverride(state)

def SoOverrideElement_getPickStyleOverride(state):
    """SoOverrideElement_getPickStyleOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getPickStyleOverride(state)

def SoOverrideElement_getPointSizeOverride(state):
    """SoOverrideElement_getPointSizeOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getPointSizeOverride(state)

def SoOverrideElement_getPolygonOffsetOverride(state):
    """SoOverrideElement_getPolygonOffsetOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getPolygonOffsetOverride(state)

def SoOverrideElement_getShapeHintsOverride(state):
    """SoOverrideElement_getShapeHintsOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getShapeHintsOverride(state)

def SoOverrideElement_getShininessOverride(state):
    """SoOverrideElement_getShininessOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getShininessOverride(state)

def SoOverrideElement_getSpecularColorOverride(state):
    """SoOverrideElement_getSpecularColorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getSpecularColorOverride(state)

def SoOverrideElement_getTransparencyOverride(state):
    """SoOverrideElement_getTransparencyOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getTransparencyOverride(state)

def SoOverrideElement_getTransparencyTypeOverride(state):
    """SoOverrideElement_getTransparencyTypeOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getTransparencyTypeOverride(state)

def SoOverrideElement_getNormalVectorOverride(state):
    """SoOverrideElement_getNormalVectorOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getNormalVectorOverride(state)

def SoOverrideElement_getNormalBindingOverride(state):
    """SoOverrideElement_getNormalBindingOverride(SoState state) -> SbBool"""
    return _coin.SoOverrideElement_getNormalBindingOverride(state)

def SoOverrideElement_setAmbientColorOverride(state, node, override):
    """SoOverrideElement_setAmbientColorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setAmbientColorOverride(state, node, override)

def SoOverrideElement_setColorIndexOverride(state, node, override):
    """SoOverrideElement_setColorIndexOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setColorIndexOverride(state, node, override)

def SoOverrideElement_setComplexityOverride(state, node, override):
    """SoOverrideElement_setComplexityOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setComplexityOverride(state, node, override)

def SoOverrideElement_setComplexityTypeOverride(state, node, override):
    """SoOverrideElement_setComplexityTypeOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setComplexityTypeOverride(state, node, override)

def SoOverrideElement_setCreaseAngleOverride(state, node, override):
    """SoOverrideElement_setCreaseAngleOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setCreaseAngleOverride(state, node, override)

def SoOverrideElement_setDiffuseColorOverride(state, node, override):
    """SoOverrideElement_setDiffuseColorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setDiffuseColorOverride(state, node, override)

def SoOverrideElement_setDrawStyleOverride(state, node, override):
    """SoOverrideElement_setDrawStyleOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setDrawStyleOverride(state, node, override)

def SoOverrideElement_setEmissiveColorOverride(state, node, override):
    """SoOverrideElement_setEmissiveColorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setEmissiveColorOverride(state, node, override)

def SoOverrideElement_setFontNameOverride(state, node, override):
    """SoOverrideElement_setFontNameOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setFontNameOverride(state, node, override)

def SoOverrideElement_setFontSizeOverride(state, node, override):
    """SoOverrideElement_setFontSizeOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setFontSizeOverride(state, node, override)

def SoOverrideElement_setLightModelOverride(state, node, override):
    """SoOverrideElement_setLightModelOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setLightModelOverride(state, node, override)

def SoOverrideElement_setLinePatternOverride(state, node, override):
    """SoOverrideElement_setLinePatternOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setLinePatternOverride(state, node, override)

def SoOverrideElement_setLineWidthOverride(state, node, override):
    """SoOverrideElement_setLineWidthOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setLineWidthOverride(state, node, override)

def SoOverrideElement_setMaterialBindingOverride(state, node, override):
    """SoOverrideElement_setMaterialBindingOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setMaterialBindingOverride(state, node, override)

def SoOverrideElement_setPickStyleOverride(state, node, override):
    """SoOverrideElement_setPickStyleOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setPickStyleOverride(state, node, override)

def SoOverrideElement_setPointSizeOverride(state, node, override):
    """SoOverrideElement_setPointSizeOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setPointSizeOverride(state, node, override)

def SoOverrideElement_setPolygonOffsetOverride(state, node, override):
    """SoOverrideElement_setPolygonOffsetOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setPolygonOffsetOverride(state, node, override)

def SoOverrideElement_setShapeHintsOverride(state, node, override):
    """SoOverrideElement_setShapeHintsOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setShapeHintsOverride(state, node, override)

def SoOverrideElement_setShininessOverride(state, node, override):
    """SoOverrideElement_setShininessOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setShininessOverride(state, node, override)

def SoOverrideElement_setSpecularColorOverride(state, node, override):
    """SoOverrideElement_setSpecularColorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setSpecularColorOverride(state, node, override)

def SoOverrideElement_setTransparencyOverride(state, node, override):
    """SoOverrideElement_setTransparencyOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setTransparencyOverride(state, node, override)

def SoOverrideElement_setTransparencyTypeOverride(state, node, override):
    """SoOverrideElement_setTransparencyTypeOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setTransparencyTypeOverride(state, node, override)

def SoOverrideElement_setNormalVectorOverride(state, node, override):
    """SoOverrideElement_setNormalVectorOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setNormalVectorOverride(state, node, override)

def SoOverrideElement_setNormalBindingOverride(state, node, override):
    """SoOverrideElement_setNormalBindingOverride(SoState state, SoNode node, SbBool const override)"""
    return _coin.SoOverrideElement_setNormalBindingOverride(state, node, override)

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, state):
        """init(SoPickRayElement self, SoState state)"""
        return _coin.SoPickRayElement_init(self, state)


    def matches(self, element):
        """matches(SoPickRayElement self, SoElement element) -> SbBool"""
        return _coin.SoPickRayElement_matches(self, element)


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


    def set(state, volume):
        """set(SoState state, SbViewVolume volume)"""
        return _coin.SoPickRayElement_set(state, volume)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbViewVolume"""
        return _coin.SoPickRayElement_get(state)

    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(state, volume):
    """SoPickRayElement_set(SoState state, SbViewVolume volume)"""
    return _coin.SoPickRayElement_set(state, volume)

def SoPickRayElement_get(state):
    """SoPickRayElement_get(SoState state) -> SbViewVolume"""
    return _coin.SoPickRayElement_get(state)

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(SoGLCoordinateElement self) -> SbVec3f"""
        return _coin.SoGLCoordinateElement_getPtr3(self)


    def getPtr4(self):
        """getPtr4(SoGLCoordinateElement self) -> SbVec4f"""
        return _coin.SoGLCoordinateElement_getPtr4(self)


    def send(self, index):
        """send(SoGLCoordinateElement self, int const index)"""
        return _coin.SoGLCoordinateElement_send(self, index)

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, state):
        """init(SoEnvironmentElement self, SoState state)"""
        return _coin.SoEnvironmentElement_init(self, state)


    def set(state, node, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart=0.0):
        """
        set(SoState state, SoNode node, float const ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t const fogType, SbColor fogColor, float const fogVisibility, float const fogStart=0.0)
        set(SoState state, SoNode node, float const ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t const fogType, SbColor fogColor, float const fogVisibility)
        """
        return _coin.SoEnvironmentElement_set(state, node, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

    set = staticmethod(set)

    def get(state, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart):
        """get(SoState state, float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogStart)"""
        return _coin.SoEnvironmentElement_get(state, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

    get = staticmethod(get)

    def getAmbientIntensity(state):
        """getAmbientIntensity(SoState state) -> float"""
        return _coin.SoEnvironmentElement_getAmbientIntensity(state)

    getAmbientIntensity = staticmethod(getAmbientIntensity)

    def getFogVisibility(state):
        """getFogVisibility(SoState state) -> float"""
        return _coin.SoEnvironmentElement_getFogVisibility(state)

    getFogVisibility = staticmethod(getFogVisibility)

    def getLightAttenuation(state):
        """getLightAttenuation(SoState state) -> SbVec3f"""
        return _coin.SoEnvironmentElement_getLightAttenuation(state)

    getLightAttenuation = staticmethod(getLightAttenuation)

    def getAmbientColor(state):
        """getAmbientColor(SoState state) -> SbColor"""
        return _coin.SoEnvironmentElement_getAmbientColor(state)

    getAmbientColor = staticmethod(getAmbientColor)

    def getFogColor(state):
        """getFogColor(SoState state) -> SbColor"""
        return _coin.SoEnvironmentElement_getFogColor(state)

    getFogColor = staticmethod(getFogColor)

    def getFogType(state):
        """getFogType(SoState state) -> int32_t"""
        return _coin.SoEnvironmentElement_getFogType(state)

    getFogType = staticmethod(getFogType)

    def getDefault(ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogNear):
        """getDefault(float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogNear)"""
        return _coin.SoEnvironmentElement_getDefault(ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogNear)

    getDefault = staticmethod(getDefault)

    def output(self, file):
        """output(SoEnvironmentElement self, FILE * file)"""
        return _coin.SoEnvironmentElement_output(self, file)

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(state, node, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart=0.0):
    """
    set(SoState state, SoNode node, float const ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t const fogType, SbColor fogColor, float const fogVisibility, float const fogStart=0.0)
    SoEnvironmentElement_set(SoState state, SoNode node, float const ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t const fogType, SbColor fogColor, float const fogVisibility)
    """
    return _coin.SoEnvironmentElement_set(state, node, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

def SoEnvironmentElement_get(state, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart):
    """SoEnvironmentElement_get(SoState state, float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogStart)"""
    return _coin.SoEnvironmentElement_get(state, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

def SoEnvironmentElement_getAmbientIntensity(state):
    """SoEnvironmentElement_getAmbientIntensity(SoState state) -> float"""
    return _coin.SoEnvironmentElement_getAmbientIntensity(state)

def SoEnvironmentElement_getFogVisibility(state):
    """SoEnvironmentElement_getFogVisibility(SoState state) -> float"""
    return _coin.SoEnvironmentElement_getFogVisibility(state)

def SoEnvironmentElement_getLightAttenuation(state):
    """SoEnvironmentElement_getLightAttenuation(SoState state) -> SbVec3f"""
    return _coin.SoEnvironmentElement_getLightAttenuation(state)

def SoEnvironmentElement_getAmbientColor(state):
    """SoEnvironmentElement_getAmbientColor(SoState state) -> SbColor"""
    return _coin.SoEnvironmentElement_getAmbientColor(state)

def SoEnvironmentElement_getFogColor(state):
    """SoEnvironmentElement_getFogColor(SoState state) -> SbColor"""
    return _coin.SoEnvironmentElement_getFogColor(state)

def SoEnvironmentElement_getFogType(state):
    """SoEnvironmentElement_getFogType(SoState state) -> int32_t"""
    return _coin.SoEnvironmentElement_getFogType(state)

def SoEnvironmentElement_getDefault(ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogNear):
    """SoEnvironmentElement_getDefault(float & ambientIntensity, SbColor ambientColor, SbVec3f attenuation, int32_t & fogType, SbColor fogColor, float & fogVisibility, float & fogNear)"""
    return _coin.SoEnvironmentElement_getDefault(ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogNear)

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, state):
        """init(SoGLEnvironmentElement self, SoState state)"""
        return _coin.SoGLEnvironmentElement_init(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLEnvironmentElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLEnvironmentElement_pop(self, state, prevTopElement)

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, state):
        """init(SoFontNameElement self, SoState state)"""
        return _coin.SoFontNameElement_init(self, state)


    def set(state, node, fontName):
        """set(SoState state, SoNode node, SbName fontName)"""
        return _coin.SoFontNameElement_set(state, node, fontName)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbName"""
        return _coin.SoFontNameElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SbName"""
        return _coin.SoFontNameElement_getDefault()

    getDefault = staticmethod(getDefault)

    def matches(self, element):
        """matches(SoFontNameElement self, SoElement element) -> SbBool"""
        return _coin.SoFontNameElement_matches(self, element)


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


    def output(self, file):
        """output(SoFontNameElement self, FILE * file)"""
        return _coin.SoFontNameElement_output(self, file)

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(state, node, fontName):
    """SoFontNameElement_set(SoState state, SoNode node, SbName fontName)"""
    return _coin.SoFontNameElement_set(state, node, fontName)

def SoFontNameElement_get(state):
    """SoFontNameElement_get(SoState state) -> SbName"""
    return _coin.SoFontNameElement_get(state)

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, state):
        """init(SoLightAttenuationElement self, SoState state)"""
        return _coin.SoLightAttenuationElement_init(self, state)


    def set(state, node, lightAttenuation):
        """set(SoState state, SoNode node, SbVec3f lightAttenuation)"""
        return _coin.SoLightAttenuationElement_set(state, node, lightAttenuation)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbVec3f"""
        return _coin.SoLightAttenuationElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SbVec3f"""
        return _coin.SoLightAttenuationElement_getDefault()

    getDefault = staticmethod(getDefault)

    def matches(self, element):
        """matches(SoLightAttenuationElement self, SoElement element) -> SbBool"""
        return _coin.SoLightAttenuationElement_matches(self, element)


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


    def output(self, file):
        """output(SoLightAttenuationElement self, FILE * file)"""
        return _coin.SoLightAttenuationElement_output(self, file)

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(state, node, lightAttenuation):
    """SoLightAttenuationElement_set(SoState state, SoNode node, SbVec3f lightAttenuation)"""
    return _coin.SoLightAttenuationElement_set(state, node, lightAttenuation)

def SoLightAttenuationElement_get(state):
    """SoLightAttenuationElement_get(SoState state) -> SbVec3f"""
    return _coin.SoLightAttenuationElement_get(state)

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, state):
        """init(SoPolygonOffsetElement self, SoState state)"""
        return _coin.SoPolygonOffsetElement_init(self, state)


    def set(state, node, factor, units, styles, on):
        """set(SoState state, SoNode node, float factor, float units, SoPolygonOffsetElement::Style styles, SbBool on)"""
        return _coin.SoPolygonOffsetElement_set(state, node, factor, units, styles, on)

    set = staticmethod(set)

    def get(state, factor, units, styles, on):
        """get(SoState state, float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
        return _coin.SoPolygonOffsetElement_get(state, factor, units, styles, on)

    get = staticmethod(get)

    def getDefault(factor, units, styles, on):
        """getDefault(float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
        return _coin.SoPolygonOffsetElement_getDefault(factor, units, styles, on)

    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(state, node, factor, units, styles, on):
    """SoPolygonOffsetElement_set(SoState state, SoNode node, float factor, float units, SoPolygonOffsetElement::Style styles, SbBool on)"""
    return _coin.SoPolygonOffsetElement_set(state, node, factor, units, styles, on)

def SoPolygonOffsetElement_get(state, factor, units, styles, on):
    """SoPolygonOffsetElement_get(SoState state, float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
    return _coin.SoPolygonOffsetElement_get(state, factor, units, styles, on)

def SoPolygonOffsetElement_getDefault(factor, units, styles, on):
    """SoPolygonOffsetElement_getDefault(float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
    return _coin.SoPolygonOffsetElement_getDefault(factor, units, styles, on)

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, state):
        """init(SoGLPolygonOffsetElement self, SoState state)"""
        return _coin.SoGLPolygonOffsetElement_init(self, state)


    def push(self, state):
        """push(SoGLPolygonOffsetElement self, SoState state)"""
        return _coin.SoGLPolygonOffsetElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLPolygonOffsetElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLPolygonOffsetElement_pop(self, state, prevTopElement)

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, state):
        """init(SoProjectionMatrixElement self, SoState state)"""
        return _coin.SoProjectionMatrixElement_init(self, state)


    def set(state, node):
        """set(SoState state, SoNode node)"""
        return _coin.SoProjectionMatrixElement_set(state, node)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoProjectionMatrixElement_get(state)

    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(state, node):
    """SoProjectionMatrixElement_set(SoState state, SoNode node)"""
    return _coin.SoProjectionMatrixElement_set(state, node)

def SoProjectionMatrixElement_get(state):
    """SoProjectionMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoProjectionMatrixElement_get(state)

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, state, prevTopElement):
        """pop(SoGLProjectionMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLProjectionMatrixElement_pop(self, state, prevTopElement)

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, state):
        """init(SoProfileCoordinateElement self, SoState state)"""
        return _coin.SoProfileCoordinateElement_init(self, state)


    def set2(state, node, numCoords, coords):
        """set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"""
        return _coin.SoProfileCoordinateElement_set2(state, node, numCoords, coords)

    set2 = staticmethod(set2)

    def set3(state, node, numCoords, coords):
        """set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoProfileCoordinateElement_set3(state, node, numCoords, coords)

    set3 = staticmethod(set3)

    def getInstance(state):
        """getInstance(SoState state) -> SoProfileCoordinateElement"""
        return _coin.SoProfileCoordinateElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoProfileCoordinateElement self) -> int32_t"""
        return _coin.SoProfileCoordinateElement_getNum(self)


    def get2(self, index):
        """get2(SoProfileCoordinateElement self, int const index) -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_get2(self, index)


    def get3(self, index):
        """get3(SoProfileCoordinateElement self, int const index) -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_get3(self, index)


    def is2D(self):
        """is2D(SoProfileCoordinateElement 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(SoProfileCoordinateElement self) -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_getArrayPtr2(self)


    def getArrayPtr3(self):
        """getArrayPtr3(SoProfileCoordinateElement 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(state, node, numCoords, coords):
    """SoProfileCoordinateElement_set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"""
    return _coin.SoProfileCoordinateElement_set2(state, node, numCoords, coords)

def SoProfileCoordinateElement_set3(state, node, numCoords, coords):
    """SoProfileCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
    return _coin.SoProfileCoordinateElement_set3(state, node, numCoords, coords)

def SoProfileCoordinateElement_getInstance(state):
    """SoProfileCoordinateElement_getInstance(SoState state) -> SoProfileCoordinateElement"""
    return _coin.SoProfileCoordinateElement_getInstance(state)

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, state):
        """init(SoGLTextureImageElement self, SoState state)"""
        return _coin.SoGLTextureImageElement_init(self, state)


    def push(self, state):
        """push(SoGLTextureImageElement self, SoState state)"""
        return _coin.SoGLTextureImageElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLTextureImageElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureImageElement_pop(self, state, prevTopElement)


    def set(state, node, image, model, blendColor):
        """set(SoState state, SoNode node, SoGLImage image, SoTextureImageElement::Model const model, SbColor blendColor)"""
        return _coin.SoGLTextureImageElement_set(state, node, image, model, blendColor)

    set = staticmethod(set)

    def get(state, model, blendcolor):
        """get(SoState state, SoTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage"""
        return _coin.SoGLTextureImageElement_get(state, model, blendcolor)

    get = staticmethod(get)

    def getMaxGLTextureSize():
        """getMaxGLTextureSize() -> int32_t"""
        return _coin.SoGLTextureImageElement_getMaxGLTextureSize()

    getMaxGLTextureSize = staticmethod(getMaxGLTextureSize)

    def isTextureSizeLegal(self, xsize, ysize, zsize, bytespertexel):
        """isTextureSizeLegal(SoGLTextureImageElement self, int xsize, int ysize, int zsize, int bytespertexel) -> SbBool"""
        return _coin.SoGLTextureImageElement_isTextureSizeLegal(self, xsize, ysize, zsize, bytespertexel)


    def hasTransparency(state):
        """hasTransparency(SoState state) -> SbBool"""
        return _coin.SoGLTextureImageElement_hasTransparency(state)

    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(state, node, image, model, blendColor):
    """SoGLTextureImageElement_set(SoState state, SoNode node, SoGLImage image, SoTextureImageElement::Model const model, SbColor blendColor)"""
    return _coin.SoGLTextureImageElement_set(state, node, image, model, blendColor)

def SoGLTextureImageElement_get(state, model, blendcolor):
    """SoGLTextureImageElement_get(SoState state, SoTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage"""
    return _coin.SoGLTextureImageElement_get(state, model, blendcolor)

def SoGLTextureImageElement_getMaxGLTextureSize():
    """SoGLTextureImageElement_getMaxGLTextureSize() -> int32_t"""
    return _coin.SoGLTextureImageElement_getMaxGLTextureSize()

def SoGLTextureImageElement_hasTransparency(state):
    """SoGLTextureImageElement_hasTransparency(SoState state) -> SbBool"""
    return _coin.SoGLTextureImageElement_hasTransparency(state)

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, state):
        """init(SoViewingMatrixElement self, SoState state)"""
        return _coin.SoViewingMatrixElement_init(self, state)


    def set(state, node, ViewingMatrix):
        """set(SoState state, SoNode node, SbMatrix ViewingMatrix)"""
        return _coin.SoViewingMatrixElement_set(state, node, ViewingMatrix)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbMatrix"""
        return _coin.SoViewingMatrixElement_get(state)

    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(state, node, ViewingMatrix):
    """SoViewingMatrixElement_set(SoState state, SoNode node, SbMatrix ViewingMatrix)"""
    return _coin.SoViewingMatrixElement_set(state, node, ViewingMatrix)

def SoViewingMatrixElement_get(state):
    """SoViewingMatrixElement_get(SoState state) -> SbMatrix"""
    return _coin.SoViewingMatrixElement_get(state)

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, state):
        """init(SoGLViewingMatrixElement self, SoState state)"""
        return _coin.SoGLViewingMatrixElement_init(self, state)


    def push(self, state):
        """push(SoGLViewingMatrixElement self, SoState state)"""
        return _coin.SoGLViewingMatrixElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLViewingMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLViewingMatrixElement_pop(self, state, prevTopElement)


    def getNodeId(state):
        """getNodeId(SoState state) -> uint32_t"""
        return _coin.SoGLViewingMatrixElement_getNodeId(state)

    getNodeId = staticmethod(getNodeId)

    def getResetMatrix(state):
        """getResetMatrix(SoState state) -> SbMatrix"""
        return _coin.SoGLViewingMatrixElement_getResetMatrix(state)

    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(state):
    """SoGLViewingMatrixElement_getNodeId(SoState state) -> uint32_t"""
    return _coin.SoGLViewingMatrixElement_getNodeId(state)

def SoGLViewingMatrixElement_getResetMatrix(state):
    """SoGLViewingMatrixElement_getResetMatrix(SoState state) -> SbMatrix"""
    return _coin.SoGLViewingMatrixElement_getResetMatrix(state)

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, state):
        """init(SoViewVolumeElement self, SoState state)"""
        return _coin.SoViewVolumeElement_init(self, state)


    def set(state, node, viewVolume):
        """set(SoState state, SoNode node, SbViewVolume viewVolume)"""
        return _coin.SoViewVolumeElement_set(state, node, viewVolume)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbViewVolume"""
        return _coin.SoViewVolumeElement_get(state)

    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(state, node, viewVolume):
    """SoViewVolumeElement_set(SoState state, SoNode node, SbViewVolume viewVolume)"""
    return _coin.SoViewVolumeElement_set(state, node, viewVolume)

def SoViewVolumeElement_get(state):
    """SoViewVolumeElement_get(SoState state) -> SbViewVolume"""
    return _coin.SoViewVolumeElement_get(state)

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, state):
        """init(SoGLShapeHintsElement self, SoState state)"""
        return _coin.SoGLShapeHintsElement_init(self, state)


    def push(self, state):
        """push(SoGLShapeHintsElement self, SoState state)"""
        return _coin.SoGLShapeHintsElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLShapeHintsElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLShapeHintsElement_pop(self, state, prevTopElement)


    def forceSend(*args):
        """
        forceSend(SoState state, SbBool const twoside)
        forceSend(SoState state, SbBool const ccw, SbBool const cull)
        forceSend(SoState state, SbBool const ccw, SbBool const cull, SbBool const 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 const twoside)
    forceSend(SoState state, SbBool const ccw, SbBool const cull)
    SoGLShapeHintsElement_forceSend(SoState state, SbBool const ccw, SbBool const cull, SbBool const 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, state):
        """init(SoShapeStyleElement self, SoState state)"""
        return _coin.SoShapeStyleElement_init(self, state)


    def push(self, state):
        """push(SoShapeStyleElement self, SoState state)"""
        return _coin.SoShapeStyleElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoShapeStyleElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoShapeStyleElement_pop(self, state, prevTopElement)


    def matches(self, element):
        """matches(SoShapeStyleElement self, SoElement element) -> SbBool"""
        return _coin.SoShapeStyleElement_matches(self, element)


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


    def get(state):
        """get(SoState state) -> SoShapeStyleElement"""
        return _coin.SoShapeStyleElement_get(state)

    get = staticmethod(get)

    def getFlags(self):
        """getFlags(SoShapeStyleElement self) -> unsigned int"""
        return _coin.SoShapeStyleElement_getFlags(self)


    def mightNotRender(self):
        """mightNotRender(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_mightNotRender(self)


    def needNormals(self):
        """needNormals(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_needNormals(self)


    def needTexCoords(self):
        """needTexCoords(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_needTexCoords(self)


    def getRenderCaseMask(self):
        """getRenderCaseMask(SoShapeStyleElement self) -> int"""
        return _coin.SoShapeStyleElement_getRenderCaseMask(self)


    def setDrawStyle(state, value):
        """setDrawStyle(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setDrawStyle(state, value)

    setDrawStyle = staticmethod(setDrawStyle)

    def setComplexityType(state, value):
        """setComplexityType(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setComplexityType(state, value)

    setComplexityType = staticmethod(setComplexityType)

    def setTransparencyType(state, value):
        """setTransparencyType(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setTransparencyType(state, value)

    setTransparencyType = staticmethod(setTransparencyType)

    def setTextureEnabled(state, value):
        """setTextureEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTextureEnabled(state, value)

    setTextureEnabled = staticmethod(setTextureEnabled)

    def setTexture3Enabled(state, value):
        """setTexture3Enabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTexture3Enabled(state, value)

    setTexture3Enabled = staticmethod(setTexture3Enabled)

    def setTextureFunction(state, value):
        """setTextureFunction(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTextureFunction(state, value)

    setTextureFunction = staticmethod(setTextureFunction)

    def setLightModel(state, value):
        """setLightModel(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setLightModel(state, value)

    setLightModel = staticmethod(setLightModel)

    def setOverrides(state, value):
        """setOverrides(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setOverrides(state, value)

    setOverrides = staticmethod(setOverrides)

    def isScreenDoor(state):
        """isScreenDoor(SoState state) -> SbBool"""
        return _coin.SoShapeStyleElement_isScreenDoor(state)

    isScreenDoor = staticmethod(isScreenDoor)

    def getTransparencyType(state):
        """getTransparencyType(SoState state) -> int"""
        return _coin.SoShapeStyleElement_getTransparencyType(state)

    getTransparencyType = staticmethod(getTransparencyType)

    def isTextureFunction(self):
        """isTextureFunction(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_isTextureFunction(self)


    def setBumpmapEnabled(state, value):
        """setBumpmapEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setBumpmapEnabled(state, value)

    setBumpmapEnabled = staticmethod(setBumpmapEnabled)

    def setBigImageEnabled(state, value):
        """setBigImageEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setBigImageEnabled(state, value)

    setBigImageEnabled = staticmethod(setBigImageEnabled)

    def setVertexArrayRendering(state, value):
        """setVertexArrayRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setVertexArrayRendering(state, value)

    setVertexArrayRendering = staticmethod(setVertexArrayRendering)

    def setTransparentMaterial(state, value):
        """setTransparentMaterial(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTransparentMaterial(state, value)

    setTransparentMaterial = staticmethod(setTransparentMaterial)

    def setTransparentTexture(state, value):
        """setTransparentTexture(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTransparentTexture(state, value)

    setTransparentTexture = staticmethod(setTransparentTexture)

    def setShadowMapRendering(state, value):
        """setShadowMapRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setShadowMapRendering(state, value)

    setShadowMapRendering = staticmethod(setShadowMapRendering)

    def setShadowsRendering(state, value):
        """setShadowsRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setShadowsRendering(state, value)

    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(state):
    """SoShapeStyleElement_get(SoState state) -> SoShapeStyleElement"""
    return _coin.SoShapeStyleElement_get(state)

def SoShapeStyleElement_setDrawStyle(state, value):
    """SoShapeStyleElement_setDrawStyle(SoState state, int32_t const value)"""
    return _coin.SoShapeStyleElement_setDrawStyle(state, value)

def SoShapeStyleElement_setComplexityType(state, value):
    """SoShapeStyleElement_setComplexityType(SoState state, int32_t const value)"""
    return _coin.SoShapeStyleElement_setComplexityType(state, value)

def SoShapeStyleElement_setTransparencyType(state, value):
    """SoShapeStyleElement_setTransparencyType(SoState state, int32_t const value)"""
    return _coin.SoShapeStyleElement_setTransparencyType(state, value)

def SoShapeStyleElement_setTextureEnabled(state, value):
    """SoShapeStyleElement_setTextureEnabled(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTextureEnabled(state, value)

def SoShapeStyleElement_setTexture3Enabled(state, value):
    """SoShapeStyleElement_setTexture3Enabled(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTexture3Enabled(state, value)

def SoShapeStyleElement_setTextureFunction(state, value):
    """SoShapeStyleElement_setTextureFunction(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTextureFunction(state, value)

def SoShapeStyleElement_setLightModel(state, value):
    """SoShapeStyleElement_setLightModel(SoState state, int32_t const value)"""
    return _coin.SoShapeStyleElement_setLightModel(state, value)

def SoShapeStyleElement_setOverrides(state, value):
    """SoShapeStyleElement_setOverrides(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setOverrides(state, value)

def SoShapeStyleElement_isScreenDoor(state):
    """SoShapeStyleElement_isScreenDoor(SoState state) -> SbBool"""
    return _coin.SoShapeStyleElement_isScreenDoor(state)

def SoShapeStyleElement_getTransparencyType(state):
    """SoShapeStyleElement_getTransparencyType(SoState state) -> int"""
    return _coin.SoShapeStyleElement_getTransparencyType(state)

def SoShapeStyleElement_setBumpmapEnabled(state, value):
    """SoShapeStyleElement_setBumpmapEnabled(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setBumpmapEnabled(state, value)

def SoShapeStyleElement_setBigImageEnabled(state, value):
    """SoShapeStyleElement_setBigImageEnabled(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setBigImageEnabled(state, value)

def SoShapeStyleElement_setVertexArrayRendering(state, value):
    """SoShapeStyleElement_setVertexArrayRendering(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setVertexArrayRendering(state, value)

def SoShapeStyleElement_setTransparentMaterial(state, value):
    """SoShapeStyleElement_setTransparentMaterial(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTransparentMaterial(state, value)

def SoShapeStyleElement_setTransparentTexture(state, value):
    """SoShapeStyleElement_setTransparentTexture(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setTransparentTexture(state, value)

def SoShapeStyleElement_setShadowMapRendering(state, value):
    """SoShapeStyleElement_setShadowMapRendering(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setShadowMapRendering(state, value)

def SoShapeStyleElement_setShadowsRendering(state, value):
    """SoShapeStyleElement_setShadowsRendering(SoState state, SbBool const value)"""
    return _coin.SoShapeStyleElement_setShadowsRendering(state, value)

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, state):
        """init(SoViewportRegionElement self, SoState state)"""
        return _coin.SoViewportRegionElement_init(self, state)


    def matches(self, element):
        """matches(SoViewportRegionElement self, SoElement element) -> SbBool"""
        return _coin.SoViewportRegionElement_matches(self, element)


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


    def set(state, viewportRegion):
        """set(SoState state, SbViewportRegion viewportRegion)"""
        return _coin.SoViewportRegionElement_set(state, viewportRegion)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbViewportRegion"""
        return _coin.SoViewportRegionElement_get(state)

    get = staticmethod(get)

    def output(self, file):
        """output(SoViewportRegionElement self, FILE * file)"""
        return _coin.SoViewportRegionElement_output(self, file)

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(state, viewportRegion):
    """SoViewportRegionElement_set(SoState state, SbViewportRegion viewportRegion)"""
    return _coin.SoViewportRegionElement_set(state, viewportRegion)

def SoViewportRegionElement_get(state):
    """SoViewportRegionElement_get(SoState state) -> SbViewportRegion"""
    return _coin.SoViewportRegionElement_get(state)

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, state):
        """init(SoGLViewportRegionElement self, SoState state)"""
        return _coin.SoGLViewportRegionElement_init(self, state)


    def push(self, state):
        """push(SoGLViewportRegionElement self, SoState state)"""
        return _coin.SoGLViewportRegionElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLViewportRegionElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLViewportRegionElement_pop(self, state, prevTopElement)

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, state):
        """init(SoWindowElement self, SoState state)"""
        return _coin.SoWindowElement_init(self, state)


    def push(self, state):
        """push(SoWindowElement self, SoState state)"""
        return _coin.SoWindowElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoWindowElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoWindowElement_pop(self, state, prevTopElement)


    def matches(self, element):
        """matches(SoWindowElement self, SoElement element) -> SbBool"""
        return _coin.SoWindowElement_matches(self, element)


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


    def set(state, window, context, display, action):
        """set(SoState state, void * window, void * context, void * display, SoGLRenderAction action)"""
        return _coin.SoWindowElement_set(state, window, context, display, action)

    set = staticmethod(set)

    def get(state, window, context, display, action):
        """get(SoState state, void *& window, void *& context, void *& display, SoGLRenderAction *& action)"""
        return _coin.SoWindowElement_get(state, window, context, display, action)

    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(state, window, context, display, action):
    """SoWindowElement_set(SoState state, void * window, void * context, void * display, SoGLRenderAction action)"""
    return _coin.SoWindowElement_set(state, window, context, display, action)

def SoWindowElement_get(state, window, context, display, action):
    """SoWindowElement_get(SoState state, void *& window, void *& context, void *& display, SoGLRenderAction *& action)"""
    return _coin.SoWindowElement_get(state, window, context, display, action)

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, state):
        """init(SoGLCacheContextElement self, SoState state)"""
        return _coin.SoGLCacheContextElement_init(self, state)


    def matches(self, elt):
        """matches(SoGLCacheContextElement self, SoElement elt) -> SbBool"""
        return _coin.SoGLCacheContextElement_matches(self, elt)


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


    def set(state, context, twopasstransparency, remoterendering):
        """set(SoState state, int context, SbBool twopasstransparency, SbBool remoterendering)"""
        return _coin.SoGLCacheContextElement_set(state, context, twopasstransparency, remoterendering)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_get(state)

    get = staticmethod(get)

    def getExtID(str):
        """getExtID(char const * str) -> int"""
        return _coin.SoGLCacheContextElement_getExtID(str)

    getExtID = staticmethod(getExtID)

    def getOpenGLVersion(state, major, minor):
        """getOpenGLVersion(SoState state, int & major, int & minor)"""
        return _coin.SoGLCacheContextElement_getOpenGLVersion(state, major, minor)

    getOpenGLVersion = staticmethod(getOpenGLVersion)

    def extSupported(state, extid):
        """extSupported(SoState state, int extid) -> SbBool"""
        return _coin.SoGLCacheContextElement_extSupported(state, extid)

    extSupported = staticmethod(extSupported)

    def areMipMapsFast(state):
        """areMipMapsFast(SoState state) -> SbBool"""
        return _coin.SoGLCacheContextElement_areMipMapsFast(state)

    areMipMapsFast = staticmethod(areMipMapsFast)
    DO_AUTO_CACHE = _coin.SoGLCacheContextElement_DO_AUTO_CACHE
    DONT_AUTO_CACHE = _coin.SoGLCacheContextElement_DONT_AUTO_CACHE

    def shouldAutoCache(state, bits):
        """shouldAutoCache(SoState state, int bits)"""
        return _coin.SoGLCacheContextElement_shouldAutoCache(state, bits)

    shouldAutoCache = staticmethod(shouldAutoCache)

    def setAutoCacheBits(state, bits):
        """setAutoCacheBits(SoState state, int bits)"""
        return _coin.SoGLCacheContextElement_setAutoCacheBits(state, bits)

    setAutoCacheBits = staticmethod(setAutoCacheBits)

    def resetAutoCacheBits(state):
        """resetAutoCacheBits(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_resetAutoCacheBits(state)

    resetAutoCacheBits = staticmethod(resetAutoCacheBits)

    def getIsRemoteRendering(state):
        """getIsRemoteRendering(SoState state) -> SbBool"""
        return _coin.SoGLCacheContextElement_getIsRemoteRendering(state)

    getIsRemoteRendering = staticmethod(getIsRemoteRendering)

    def getUniqueCacheContext():
        """getUniqueCacheContext() -> uint32_t"""
        return _coin.SoGLCacheContextElement_getUniqueCacheContext()

    getUniqueCacheContext = staticmethod(getUniqueCacheContext)

    def scheduleDeleteCallback(contextid, cb, closure):
        """scheduleDeleteCallback(uint32_t const contextid, SoScheduleDeleteCB * cb, void * closure)"""
        return _coin.SoGLCacheContextElement_scheduleDeleteCallback(contextid, cb, closure)

    scheduleDeleteCallback = staticmethod(scheduleDeleteCallback)

    def incNumShapes(state):
        """incNumShapes(SoState state)"""
        return _coin.SoGLCacheContextElement_incNumShapes(state)

    incNumShapes = staticmethod(incNumShapes)

    def getNumShapes(state):
        """getNumShapes(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_getNumShapes(state)

    getNumShapes = staticmethod(getNumShapes)

    def incNumSeparators(state):
        """incNumSeparators(SoState state)"""
        return _coin.SoGLCacheContextElement_incNumSeparators(state)

    incNumSeparators = staticmethod(incNumSeparators)

    def getNumSeparators(state):
        """getNumSeparators(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_getNumSeparators(state)

    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(state, context, twopasstransparency, remoterendering):
    """SoGLCacheContextElement_set(SoState state, int context, SbBool twopasstransparency, SbBool remoterendering)"""
    return _coin.SoGLCacheContextElement_set(state, context, twopasstransparency, remoterendering)

def SoGLCacheContextElement_get(state):
    """SoGLCacheContextElement_get(SoState state) -> int"""
    return _coin.SoGLCacheContextElement_get(state)

def SoGLCacheContextElement_getExtID(str):
    """SoGLCacheContextElement_getExtID(char const * str) -> int"""
    return _coin.SoGLCacheContextElement_getExtID(str)

def SoGLCacheContextElement_getOpenGLVersion(state, major, minor):
    """SoGLCacheContextElement_getOpenGLVersion(SoState state, int & major, int & minor)"""
    return _coin.SoGLCacheContextElement_getOpenGLVersion(state, major, minor)

def SoGLCacheContextElement_extSupported(state, extid):
    """SoGLCacheContextElement_extSupported(SoState state, int extid) -> SbBool"""
    return _coin.SoGLCacheContextElement_extSupported(state, extid)

def SoGLCacheContextElement_areMipMapsFast(state):
    """SoGLCacheContextElement_areMipMapsFast(SoState state) -> SbBool"""
    return _coin.SoGLCacheContextElement_areMipMapsFast(state)

def SoGLCacheContextElement_shouldAutoCache(state, bits):
    """SoGLCacheContextElement_shouldAutoCache(SoState state, int bits)"""
    return _coin.SoGLCacheContextElement_shouldAutoCache(state, bits)

def SoGLCacheContextElement_setAutoCacheBits(state, bits):
    """SoGLCacheContextElement_setAutoCacheBits(SoState state, int bits)"""
    return _coin.SoGLCacheContextElement_setAutoCacheBits(state, bits)

def SoGLCacheContextElement_resetAutoCacheBits(state):
    """SoGLCacheContextElement_resetAutoCacheBits(SoState state) -> int"""
    return _coin.SoGLCacheContextElement_resetAutoCacheBits(state)

def SoGLCacheContextElement_getIsRemoteRendering(state):
    """SoGLCacheContextElement_getIsRemoteRendering(SoState state) -> SbBool"""
    return _coin.SoGLCacheContextElement_getIsRemoteRendering(state)

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

def SoGLCacheContextElement_scheduleDeleteCallback(contextid, cb, closure):
    """SoGLCacheContextElement_scheduleDeleteCallback(uint32_t const contextid, SoScheduleDeleteCB * cb, void * closure)"""
    return _coin.SoGLCacheContextElement_scheduleDeleteCallback(contextid, cb, closure)

def SoGLCacheContextElement_incNumShapes(state):
    """SoGLCacheContextElement_incNumShapes(SoState state)"""
    return _coin.SoGLCacheContextElement_incNumShapes(state)

def SoGLCacheContextElement_getNumShapes(state):
    """SoGLCacheContextElement_getNumShapes(SoState state) -> int"""
    return _coin.SoGLCacheContextElement_getNumShapes(state)

def SoGLCacheContextElement_incNumSeparators(state):
    """SoGLCacheContextElement_incNumSeparators(SoState state)"""
    return _coin.SoGLCacheContextElement_incNumSeparators(state)

def SoGLCacheContextElement_getNumSeparators(state):
    """SoGLCacheContextElement_getNumSeparators(SoState state) -> int"""
    return _coin.SoGLCacheContextElement_getNumSeparators(state)

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, state, type, allocnum=1, mipmaptexobj=0):
        """
        __init__(SoGLDisplayList self, SoState state, SoGLDisplayList::Type type, int allocnum=1, SbBool mipmaptexobj=0) -> SoGLDisplayList
        __init__(SoGLDisplayList self, SoState state, SoGLDisplayList::Type type, int allocnum=1) -> SoGLDisplayList
        __init__(SoGLDisplayList self, SoState state, SoGLDisplayList::Type type) -> SoGLDisplayList
        """
        this = _coin.new_SoGLDisplayList(state, type, allocnum, mipmaptexobj)
        try:
            self.this.append(this)
        except:
            self.this = this

    def ref(self):
        """ref(SoGLDisplayList self)"""
        return _coin.SoGLDisplayList_ref(self)


    def unref(self, state=None):
        """
        unref(SoGLDisplayList self, SoState state=None)
        unref(SoGLDisplayList self)
        """
        return _coin.SoGLDisplayList_unref(self, state)


    def open(self, state, index=0):
        """
        open(SoGLDisplayList self, SoState state, int index=0)
        open(SoGLDisplayList self, SoState state)
        """
        return _coin.SoGLDisplayList_open(self, state, index)


    def close(self, state):
        """close(SoGLDisplayList self, SoState state)"""
        return _coin.SoGLDisplayList_close(self, state)


    def call(self, state, index=0):
        """
        call(SoGLDisplayList self, SoState state, int index=0)
        call(SoGLDisplayList self, SoState state)
        """
        return _coin.SoGLDisplayList_call(self, state, index)


    def addDependency(self, state):
        """addDependency(SoGLDisplayList self, SoState state)"""
        return _coin.SoGLDisplayList_addDependency(self, state)


    def isMipMapTextureObject(self):
        """isMipMapTextureObject(SoGLDisplayList self) -> SbBool"""
        return _coin.SoGLDisplayList_isMipMapTextureObject(self)


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


    def getNumAllocated(self):
        """getNumAllocated(SoGLDisplayList self) -> int"""
        return _coin.SoGLDisplayList_getNumAllocated(self)


    def getFirstIndex(self):
        """getFirstIndex(SoGLDisplayList self) -> unsigned int"""
        return _coin.SoGLDisplayList_getFirstIndex(self)


    def getContext(self):
        """getContext(SoGLDisplayList self) -> int"""
        return _coin.SoGLDisplayList_getContext(self)


    def setTextureTarget(self, target):
        """setTextureTarget(SoGLDisplayList self, int target)"""
        return _coin.SoGLDisplayList_setTextureTarget(self, target)


    def getTextureTarget(self):
        """getTextureTarget(SoGLDisplayList 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(state):
        """isColorIndexMode(SoState state) -> SbBool"""
        return _coin.SoGLColorIndexElement_isColorIndexMode(state)

    isColorIndexMode = staticmethod(isColorIndexMode)

    def init(self, state):
        """init(SoGLColorIndexElement self, SoState state)"""
        return _coin.SoGLColorIndexElement_init(self, state)


    def set(state, node, numindices, indices):
        """set(SoState state, SoNode node, int32_t const numindices, int32_t const *const indices)"""
        return _coin.SoGLColorIndexElement_set(state, node, numindices, indices)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoGLColorIndexElement"""
        return _coin.SoGLColorIndexElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoGLColorIndexElement self) -> int32_t"""
        return _coin.SoGLColorIndexElement_getNum(self)


    def get(self, index):
        """get(SoGLColorIndexElement self, int const index) -> int32_t"""
        return _coin.SoGLColorIndexElement_get(self, index)


    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(state):
    """SoGLColorIndexElement_isColorIndexMode(SoState state) -> SbBool"""
    return _coin.SoGLColorIndexElement_isColorIndexMode(state)

def SoGLColorIndexElement_set(state, node, numindices, indices):
    """SoGLColorIndexElement_set(SoState state, SoNode node, int32_t const numindices, int32_t const *const indices)"""
    return _coin.SoGLColorIndexElement_set(state, node, numindices, indices)

def SoGLColorIndexElement_getInstance(state):
    """SoGLColorIndexElement_getInstance(SoState state) -> SoGLColorIndexElement"""
    return _coin.SoGLColorIndexElement_getInstance(state)

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, state):
        """init(SoListenerPositionElement self, SoState state)"""
        return _coin.SoListenerPositionElement_init(self, state)


    def set(state, node, position, setbylistener):
        """set(SoState state, SoNode node, SbVec3f position, SbBool setbylistener)"""
        return _coin.SoListenerPositionElement_set(state, node, position, setbylistener)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbVec3f"""
        return _coin.SoListenerPositionElement_get(state)

    get = staticmethod(get)

    def isSetByListener(state):
        """isSetByListener(SoState state) -> SbBool"""
        return _coin.SoListenerPositionElement_isSetByListener(state)

    isSetByListener = staticmethod(isSetByListener)

    def output(self, file):
        """output(SoListenerPositionElement self, FILE * file)"""
        return _coin.SoListenerPositionElement_output(self, file)

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(state, node, position, setbylistener):
    """SoListenerPositionElement_set(SoState state, SoNode node, SbVec3f position, SbBool setbylistener)"""
    return _coin.SoListenerPositionElement_set(state, node, position, setbylistener)

def SoListenerPositionElement_get(state):
    """SoListenerPositionElement_get(SoState state) -> SbVec3f"""
    return _coin.SoListenerPositionElement_get(state)

def SoListenerPositionElement_isSetByListener(state):
    """SoListenerPositionElement_isSetByListener(SoState state) -> SbBool"""
    return _coin.SoListenerPositionElement_isSetByListener(state)

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, state):
        """init(SoListenerOrientationElement self, SoState state)"""
        return _coin.SoListenerOrientationElement_init(self, state)


    def set(state, node, orientation, setbylistener):
        """set(SoState state, SoNode node, SbRotation orientation, SbBool setbylistener)"""
        return _coin.SoListenerOrientationElement_set(state, node, orientation, setbylistener)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SbRotation"""
        return _coin.SoListenerOrientationElement_get(state)

    get = staticmethod(get)

    def isSetByListener(state):
        """isSetByListener(SoState state) -> SbBool"""
        return _coin.SoListenerOrientationElement_isSetByListener(state)

    isSetByListener = staticmethod(isSetByListener)

    def output(self, file):
        """output(SoListenerOrientationElement self, FILE * file)"""
        return _coin.SoListenerOrientationElement_output(self, file)

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(state, node, orientation, setbylistener):
    """SoListenerOrientationElement_set(SoState state, SoNode node, SbRotation orientation, SbBool setbylistener)"""
    return _coin.SoListenerOrientationElement_set(state, node, orientation, setbylistener)

def SoListenerOrientationElement_get(state):
    """SoListenerOrientationElement_get(SoState state) -> SbRotation"""
    return _coin.SoListenerOrientationElement_get(state)

def SoListenerOrientationElement_isSetByListener(state):
    """SoListenerOrientationElement_isSetByListener(SoState state) -> SbBool"""
    return _coin.SoListenerOrientationElement_isSetByListener(state)

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, state):
        """init(SoListenerDopplerElement self, SoState state)"""
        return _coin.SoListenerDopplerElement_init(self, state)


    def setDopplerVelocity(state, node, velocity):
        """setDopplerVelocity(SoState state, SoNode node, SbVec3f velocity)"""
        return _coin.SoListenerDopplerElement_setDopplerVelocity(state, node, velocity)

    setDopplerVelocity = staticmethod(setDopplerVelocity)

    def setDopplerFactor(state, node, factor):
        """setDopplerFactor(SoState state, SoNode node, float factor)"""
        return _coin.SoListenerDopplerElement_setDopplerFactor(state, node, factor)

    setDopplerFactor = staticmethod(setDopplerFactor)

    def getDopplerVelocity(state):
        """getDopplerVelocity(SoState state) -> SbVec3f"""
        return _coin.SoListenerDopplerElement_getDopplerVelocity(state)

    getDopplerVelocity = staticmethod(getDopplerVelocity)

    def getDopplerFactor(state):
        """getDopplerFactor(SoState state) -> float"""
        return _coin.SoListenerDopplerElement_getDopplerFactor(state)

    getDopplerFactor = staticmethod(getDopplerFactor)

    def output(self, file):
        """output(SoListenerDopplerElement self, FILE * file)"""
        return _coin.SoListenerDopplerElement_output(self, file)

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(state, node, velocity):
    """SoListenerDopplerElement_setDopplerVelocity(SoState state, SoNode node, SbVec3f velocity)"""
    return _coin.SoListenerDopplerElement_setDopplerVelocity(state, node, velocity)

def SoListenerDopplerElement_setDopplerFactor(state, node, factor):
    """SoListenerDopplerElement_setDopplerFactor(SoState state, SoNode node, float factor)"""
    return _coin.SoListenerDopplerElement_setDopplerFactor(state, node, factor)

def SoListenerDopplerElement_getDopplerVelocity(state):
    """SoListenerDopplerElement_getDopplerVelocity(SoState state) -> SbVec3f"""
    return _coin.SoListenerDopplerElement_getDopplerVelocity(state)

def SoListenerDopplerElement_getDopplerFactor(state):
    """SoListenerDopplerElement_getDopplerFactor(SoState state) -> float"""
    return _coin.SoListenerDopplerElement_getDopplerFactor(state)

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, state):
        """init(SoListenerGainElement self, SoState state)"""
        return _coin.SoListenerGainElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, float const gain)
        set(SoState state, float const gain)
        """
        return _coin.SoListenerGainElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> float"""
        return _coin.SoListenerGainElement_get(state)

    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 const gain)
    SoListenerGainElement_set(SoState state, float const gain)
    """
    return _coin.SoListenerGainElement_set(*args)

def SoListenerGainElement_get(state):
    """SoListenerGainElement_get(SoState state) -> float"""
    return _coin.SoListenerGainElement_get(state)

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, state):
        """init(SoSoundElement self, SoState state)"""
        return _coin.SoSoundElement_init(self, state)


    def set(state, node, scenegraphhassoundnode, soundnodeisplaying, ispartofactivescenegraph):
        """set(SoState state, SoNode node, SbBool scenegraphhassoundnode, SbBool soundnodeisplaying, SbBool ispartofactivescenegraph)"""
        return _coin.SoSoundElement_set(state, node, scenegraphhassoundnode, soundnodeisplaying, ispartofactivescenegraph)

    set = staticmethod(set)

    def setSceneGraphHasSoundNode(state, node, flag):
        """setSceneGraphHasSoundNode(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setSceneGraphHasSoundNode(state, node, flag)

    setSceneGraphHasSoundNode = staticmethod(setSceneGraphHasSoundNode)

    def sceneGraphHasSoundNode(state):
        """sceneGraphHasSoundNode(SoState state) -> SbBool"""
        return _coin.SoSoundElement_sceneGraphHasSoundNode(state)

    sceneGraphHasSoundNode = staticmethod(sceneGraphHasSoundNode)

    def setSoundNodeIsPlaying(state, node, flag):
        """setSoundNodeIsPlaying(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setSoundNodeIsPlaying(state, node, flag)

    setSoundNodeIsPlaying = staticmethod(setSoundNodeIsPlaying)

    def soundNodeIsPlaying(state):
        """soundNodeIsPlaying(SoState state) -> SbBool"""
        return _coin.SoSoundElement_soundNodeIsPlaying(state)

    soundNodeIsPlaying = staticmethod(soundNodeIsPlaying)

    def setIsPartOfActiveSceneGraph(state, node, flag):
        """setIsPartOfActiveSceneGraph(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setIsPartOfActiveSceneGraph(state, node, flag)

    setIsPartOfActiveSceneGraph = staticmethod(setIsPartOfActiveSceneGraph)

    def isPartOfActiveSceneGraph(state):
        """isPartOfActiveSceneGraph(SoState state) -> SbBool"""
        return _coin.SoSoundElement_isPartOfActiveSceneGraph(state)

    isPartOfActiveSceneGraph = staticmethod(isPartOfActiveSceneGraph)

    def push(self, state):
        """push(SoSoundElement self, SoState state)"""
        return _coin.SoSoundElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoSoundElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoSoundElement_pop(self, state, prevTopElement)


    def output(self, file):
        """output(SoSoundElement self, FILE * file)"""
        return _coin.SoSoundElement_output(self, file)

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(state, node, scenegraphhassoundnode, soundnodeisplaying, ispartofactivescenegraph):
    """SoSoundElement_set(SoState state, SoNode node, SbBool scenegraphhassoundnode, SbBool soundnodeisplaying, SbBool ispartofactivescenegraph)"""
    return _coin.SoSoundElement_set(state, node, scenegraphhassoundnode, soundnodeisplaying, ispartofactivescenegraph)

def SoSoundElement_setSceneGraphHasSoundNode(state, node, flag):
    """SoSoundElement_setSceneGraphHasSoundNode(SoState state, SoNode node, SbBool flag) -> SbBool"""
    return _coin.SoSoundElement_setSceneGraphHasSoundNode(state, node, flag)

def SoSoundElement_sceneGraphHasSoundNode(state):
    """SoSoundElement_sceneGraphHasSoundNode(SoState state) -> SbBool"""
    return _coin.SoSoundElement_sceneGraphHasSoundNode(state)

def SoSoundElement_setSoundNodeIsPlaying(state, node, flag):
    """SoSoundElement_setSoundNodeIsPlaying(SoState state, SoNode node, SbBool flag) -> SbBool"""
    return _coin.SoSoundElement_setSoundNodeIsPlaying(state, node, flag)

def SoSoundElement_soundNodeIsPlaying(state):
    """SoSoundElement_soundNodeIsPlaying(SoState state) -> SbBool"""
    return _coin.SoSoundElement_soundNodeIsPlaying(state)

def SoSoundElement_setIsPartOfActiveSceneGraph(state, node, flag):
    """SoSoundElement_setIsPartOfActiveSceneGraph(SoState state, SoNode node, SbBool flag) -> SbBool"""
    return _coin.SoSoundElement_setIsPartOfActiveSceneGraph(state, node, flag)

def SoSoundElement_isPartOfActiveSceneGraph(state):
    """SoSoundElement_isPartOfActiveSceneGraph(SoState state) -> SbBool"""
    return _coin.SoSoundElement_isPartOfActiveSceneGraph(state)

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(state, numdata):
        """shouldCreateVBO(SoState state, int const numdata) -> SbBool"""
        return _coin.SoGLVBOElement_shouldCreateVBO(state, numdata)

    shouldCreateVBO = staticmethod(shouldCreateVBO)

    def setVertexVBO(state, vbo):
        """setVertexVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setVertexVBO(state, vbo)

    setVertexVBO = staticmethod(setVertexVBO)

    def setNormalVBO(state, vbo):
        """setNormalVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setNormalVBO(state, vbo)

    setNormalVBO = staticmethod(setNormalVBO)

    def setColorVBO(state, vbo):
        """setColorVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setColorVBO(state, vbo)

    setColorVBO = staticmethod(setColorVBO)

    def setTexCoordVBO(state, unit, vbo):
        """setTexCoordVBO(SoState state, int const unit, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setTexCoordVBO(state, unit, vbo)

    setTexCoordVBO = staticmethod(setTexCoordVBO)

    def getInstance(state):
        """getInstance(SoState state) -> SoGLVBOElement"""
        return _coin.SoGLVBOElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def init(self, state):
        """init(SoGLVBOElement self, SoState state)"""
        return _coin.SoGLVBOElement_init(self, state)


    def push(self, state):
        """push(SoGLVBOElement self, SoState state)"""
        return _coin.SoGLVBOElement_push(self, state)


    def pop(self, state, prevtopelement):
        """pop(SoGLVBOElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoGLVBOElement_pop(self, state, prevtopelement)


    def matches(self, elt):
        """matches(SoGLVBOElement self, SoElement elt) -> SbBool"""
        return _coin.SoGLVBOElement_matches(self, elt)


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


    def getVertexVBO(self):
        """getVertexVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getVertexVBO(self)


    def getNormalVBO(self):
        """getNormalVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getNormalVBO(self)


    def getColorVBO(self):
        """getColorVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getColorVBO(self)


    def getNumTexCoordVBO(self):
        """getNumTexCoordVBO(SoGLVBOElement self) -> int"""
        return _coin.SoGLVBOElement_getNumTexCoordVBO(self)


    def getTexCoordVBO(self, idx):
        """getTexCoordVBO(SoGLVBOElement self, int const idx) -> SoVBO *"""
        return _coin.SoGLVBOElement_getTexCoordVBO(self, idx)

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(state, numdata):
    """SoGLVBOElement_shouldCreateVBO(SoState state, int const numdata) -> SbBool"""
    return _coin.SoGLVBOElement_shouldCreateVBO(state, numdata)

def SoGLVBOElement_setVertexVBO(state, vbo):
    """SoGLVBOElement_setVertexVBO(SoState state, SoVBO * vbo)"""
    return _coin.SoGLVBOElement_setVertexVBO(state, vbo)

def SoGLVBOElement_setNormalVBO(state, vbo):
    """SoGLVBOElement_setNormalVBO(SoState state, SoVBO * vbo)"""
    return _coin.SoGLVBOElement_setNormalVBO(state, vbo)

def SoGLVBOElement_setColorVBO(state, vbo):
    """SoGLVBOElement_setColorVBO(SoState state, SoVBO * vbo)"""
    return _coin.SoGLVBOElement_setColorVBO(state, vbo)

def SoGLVBOElement_setTexCoordVBO(state, unit, vbo):
    """SoGLVBOElement_setTexCoordVBO(SoState state, int const unit, SoVBO * vbo)"""
    return _coin.SoGLVBOElement_setTexCoordVBO(state, unit, vbo)

def SoGLVBOElement_getInstance(state):
    """SoGLVBOElement_getInstance(SoState state) -> SoGLVBOElement"""
    return _coin.SoGLVBOElement_getInstance(state)

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(state, test, write, function, range):
        """set(SoState state, SbBool test, SbBool write, SoDepthBufferElement::DepthWriteFunction function, SbVec2f range)"""
        return _coin.SoDepthBufferElement_set(state, test, write, function, range)

    set = staticmethod(set)

    def get(state, test_out, write_out, function_out, range_out):
        """get(SoState state, SbBool & test_out, SbBool & write_out, SoDepthBufferElement::DepthWriteFunction & function_out, SbVec2f range_out)"""
        return _coin.SoDepthBufferElement_get(state, test_out, write_out, function_out, range_out)

    get = staticmethod(get)

    def getTestEnable(state):
        """getTestEnable(SoState state) -> SbBool"""
        return _coin.SoDepthBufferElement_getTestEnable(state)

    getTestEnable = staticmethod(getTestEnable)

    def getWriteEnable(state):
        """getWriteEnable(SoState state) -> SbBool"""
        return _coin.SoDepthBufferElement_getWriteEnable(state)

    getWriteEnable = staticmethod(getWriteEnable)

    def getFunction(state):
        """getFunction(SoState state) -> SoDepthBufferElement::DepthWriteFunction"""
        return _coin.SoDepthBufferElement_getFunction(state)

    getFunction = staticmethod(getFunction)

    def getRange(state):
        """getRange(SoState state) -> SbVec2f"""
        return _coin.SoDepthBufferElement_getRange(state)

    getRange = staticmethod(getRange)

    def init(self, state):
        """init(SoDepthBufferElement self, SoState state)"""
        return _coin.SoDepthBufferElement_init(self, state)


    def push(self, state):
        """push(SoDepthBufferElement self, SoState state)"""
        return _coin.SoDepthBufferElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoDepthBufferElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoDepthBufferElement_pop(self, state, prevTopElement)


    def matches(self, element):
        """matches(SoDepthBufferElement self, SoElement element) -> SbBool"""
        return _coin.SoDepthBufferElement_matches(self, element)


    def copyMatchInfo(self):
        """copyMatchInfo(SoDepthBufferElement 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(state, test, write, function, range):
    """SoDepthBufferElement_set(SoState state, SbBool test, SbBool write, SoDepthBufferElement::DepthWriteFunction function, SbVec2f range)"""
    return _coin.SoDepthBufferElement_set(state, test, write, function, range)

def SoDepthBufferElement_get(state, test_out, write_out, function_out, range_out):
    """SoDepthBufferElement_get(SoState state, SbBool & test_out, SbBool & write_out, SoDepthBufferElement::DepthWriteFunction & function_out, SbVec2f range_out)"""
    return _coin.SoDepthBufferElement_get(state, test_out, write_out, function_out, range_out)

def SoDepthBufferElement_getTestEnable(state):
    """SoDepthBufferElement_getTestEnable(SoState state) -> SbBool"""
    return _coin.SoDepthBufferElement_getTestEnable(state)

def SoDepthBufferElement_getWriteEnable(state):
    """SoDepthBufferElement_getWriteEnable(SoState state) -> SbBool"""
    return _coin.SoDepthBufferElement_getWriteEnable(state)

def SoDepthBufferElement_getFunction(state):
    """SoDepthBufferElement_getFunction(SoState state) -> SoDepthBufferElement::DepthWriteFunction"""
    return _coin.SoDepthBufferElement_getFunction(state)

def SoDepthBufferElement_getRange(state):
    """SoDepthBufferElement_getRange(SoState state) -> SbVec2f"""
    return _coin.SoDepthBufferElement_getRange(state)

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, state):
        """init(SoGLDepthBufferElement self, SoState state)"""
        return _coin.SoGLDepthBufferElement_init(self, state)


    def push(self, state):
        """push(SoGLDepthBufferElement self, SoState state)"""
        return _coin.SoGLDepthBufferElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLDepthBufferElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLDepthBufferElement_pop(self, state, prevTopElement)

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, state):
        """init(SoVertexAttributeElement self, SoState state)"""
        return _coin.SoVertexAttributeElement_init(self, state)


    def push(self, state):
        """push(SoVertexAttributeElement self, SoState state)"""
        return _coin.SoVertexAttributeElement_push(self, state)


    def add(state, attribdata):
        """add(SoState state, SoVertexAttributeData * attribdata)"""
        return _coin.SoVertexAttributeElement_add(state, attribdata)

    add = staticmethod(add)

    def getInstance(state):
        """getInstance(SoState state) -> SoVertexAttributeElement"""
        return _coin.SoVertexAttributeElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNumAttributes(self):
        """getNumAttributes(SoVertexAttributeElement self) -> unsigned int"""
        return _coin.SoVertexAttributeElement_getNumAttributes(self)


    def applyToAttributes(self, func, closure):
        """applyToAttributes(SoVertexAttributeElement self, SoVertexAttributeElement::AttributeApplyFunc * func, void * closure)"""
        return _coin.SoVertexAttributeElement_applyToAttributes(self, func, closure)

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(state, attribdata):
    """SoVertexAttributeElement_add(SoState state, SoVertexAttributeData * attribdata)"""
    return _coin.SoVertexAttributeElement_add(state, attribdata)

def SoVertexAttributeElement_getInstance(state):
    """SoVertexAttributeElement_getInstance(SoState state) -> SoVertexAttributeElement"""
    return _coin.SoVertexAttributeElement_getInstance(state)

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, state):
        """init(SoGLVertexAttributeElement self, SoState state)"""
        return _coin.SoGLVertexAttributeElement_init(self, state)


    def enableVBO(self, action):
        """enableVBO(SoGLVertexAttributeElement self, SoGLRenderAction action)"""
        return _coin.SoGLVertexAttributeElement_enableVBO(self, action)


    def disableVBO(self, action):
        """disableVBO(SoGLVertexAttributeElement self, SoGLRenderAction action)"""
        return _coin.SoGLVertexAttributeElement_disableVBO(self, action)


    def send(self, index):
        """send(SoGLVertexAttributeElement self, int const index)"""
        return _coin.SoGLVertexAttributeElement_send(self, index)


    def getInstance(state):
        """getInstance(SoState state) -> SoGLVertexAttributeElement"""
        return _coin.SoGLVertexAttributeElement_getInstance(state)

    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(state):
    """SoGLVertexAttributeElement_getInstance(SoState state) -> SoGLVertexAttributeElement"""
    return _coin.SoGLVertexAttributeElement_getInstance(state)

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, state):
        """init(SoVertexAttributeBindingElement self, SoState state)"""
        return _coin.SoVertexAttributeBindingElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoNode node, SoVertexAttributeBindingElement::Binding const binding)
        set(SoState state, SoVertexAttributeBindingElement::Binding const binding)
        """
        return _coin.SoVertexAttributeBindingElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoVertexAttributeBindingElement::Binding"""
        return _coin.SoVertexAttributeBindingElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoVertexAttributeBindingElement::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, SoVertexAttributeBindingElement::Binding const binding)
    SoVertexAttributeBindingElement_set(SoState state, SoVertexAttributeBindingElement::Binding const binding)
    """
    return _coin.SoVertexAttributeBindingElement_set(*args)

def SoVertexAttributeBindingElement_get(state):
    """SoVertexAttributeBindingElement_get(SoState state) -> SoVertexAttributeBindingElement::Binding"""
    return _coin.SoVertexAttributeBindingElement_get(state)

def SoVertexAttributeBindingElement_getDefault():
    """SoVertexAttributeBindingElement_getDefault() -> SoVertexAttributeBindingElement::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, state):
        """init(SoSpecularColorElement self, SoState state)"""
        return _coin.SoSpecularColorElement_init(self, state)


    def set(state, node, numColors, colors):
        """set(SoState state, SoNode node, int32_t const numColors, SbColor colors)"""
        return _coin.SoSpecularColorElement_set(state, node, numColors, colors)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoSpecularColorElement"""
        return _coin.SoSpecularColorElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoSpecularColorElement self) -> int32_t"""
        return _coin.SoSpecularColorElement_getNum(self)


    def get(self, index):
        """get(SoSpecularColorElement self, int const index) -> SbColor"""
        return _coin.SoSpecularColorElement_get(self, index)


    def getArrayPtr(self):
        """getArrayPtr(SoSpecularColorElement 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(state, node, numColors, colors):
    """SoSpecularColorElement_set(SoState state, SoNode node, int32_t const numColors, SbColor colors)"""
    return _coin.SoSpecularColorElement_set(state, node, numColors, colors)

def SoSpecularColorElement_getInstance(state):
    """SoSpecularColorElement_getInstance(SoState state) -> SoSpecularColorElement"""
    return _coin.SoSpecularColorElement_getInstance(state)

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, state):
        """init(SoEmissiveColorElement self, SoState state)"""
        return _coin.SoEmissiveColorElement_init(self, state)


    def set(state, node, numcolors, colors):
        """set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoEmissiveColorElement_set(state, node, numcolors, colors)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoEmissiveColorElement"""
        return _coin.SoEmissiveColorElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoEmissiveColorElement self) -> int32_t"""
        return _coin.SoEmissiveColorElement_getNum(self)


    def get(self, index):
        """get(SoEmissiveColorElement self, int const index) -> SbColor"""
        return _coin.SoEmissiveColorElement_get(self, index)


    def getArrayPtr(self):
        """getArrayPtr(SoEmissiveColorElement 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(state, node, numcolors, colors):
    """SoEmissiveColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
    return _coin.SoEmissiveColorElement_set(state, node, numcolors, colors)

def SoEmissiveColorElement_getInstance(state):
    """SoEmissiveColorElement_getInstance(SoState state) -> SoEmissiveColorElement"""
    return _coin.SoEmissiveColorElement_getInstance(state)

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, state):
        """init(SoShininessElement self, SoState state)"""
        return _coin.SoShininessElement_init(self, state)


    def set(state, node, numvalues, values):
        """set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
        return _coin.SoShininessElement_set(state, node, numvalues, values)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoShininessElement"""
        return _coin.SoShininessElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoShininessElement self) -> int32_t"""
        return _coin.SoShininessElement_getNum(self)


    def get(self, index):
        """get(SoShininessElement self, int const index) -> float"""
        return _coin.SoShininessElement_get(self, index)


    def getArrayPtr(self):
        """getArrayPtr(SoShininessElement self) -> float const *"""
        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(state, node, numvalues, values):
    """SoShininessElement_set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
    return _coin.SoShininessElement_set(state, node, numvalues, values)

def SoShininessElement_getInstance(state):
    """SoShininessElement_getInstance(SoState state) -> SoShininessElement"""
    return _coin.SoShininessElement_getInstance(state)

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, state):
        """init(SoTransparencyElement self, SoState state)"""
        return _coin.SoTransparencyElement_init(self, state)


    def set(state, node, numvalues, values):
        """set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
        return _coin.SoTransparencyElement_set(state, node, numvalues, values)

    set = staticmethod(set)

    def getInstance(state):
        """getInstance(SoState state) -> SoTransparencyElement"""
        return _coin.SoTransparencyElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def getNum(self):
        """getNum(SoTransparencyElement self) -> int32_t"""
        return _coin.SoTransparencyElement_getNum(self)


    def get(self, index):
        """get(SoTransparencyElement self, int const index) -> float"""
        return _coin.SoTransparencyElement_get(self, index)


    def getArrayPtr(self):
        """getArrayPtr(SoTransparencyElement self) -> float const *"""
        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(state, node, numvalues, values):
    """SoTransparencyElement_set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
    return _coin.SoTransparencyElement_set(state, node, numvalues, values)

def SoTransparencyElement_getInstance(state):
    """SoTransparencyElement_getInstance(SoState state) -> SoTransparencyElement"""
    return _coin.SoTransparencyElement_getInstance(state)

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, state):
        """init(SoLightModelElement self, SoState state)"""
        return _coin.SoLightModelElement_init(self, state)


    def set(*args):
        """
        set(SoState state, SoLightModelElement::Model const model)
        set(SoState state, SoNode node, SoLightModelElement::Model const model)
        """
        return _coin.SoLightModelElement_set(*args)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> SoLightModelElement::Model"""
        return _coin.SoLightModelElement_get(state)

    get = staticmethod(get)

    def getDefault():
        """getDefault() -> SoLightModelElement::Model"""
        return _coin.SoLightModelElement_getDefault()

    getDefault = staticmethod(getDefault)

    def getInstance(state):
        """getInstance(SoState state) -> SoLightModelElement"""
        return _coin.SoLightModelElement_getInstance(state)

    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, SoLightModelElement::Model const model)
    SoLightModelElement_set(SoState state, SoNode node, SoLightModelElement::Model const model)
    """
    return _coin.SoLightModelElement_set(*args)

def SoLightModelElement_get(state):
    """SoLightModelElement_get(SoState state) -> SoLightModelElement::Model"""
    return _coin.SoLightModelElement_get(state)

def SoLightModelElement_getDefault():
    """SoLightModelElement_getDefault() -> SoLightModelElement::Model"""
    return _coin.SoLightModelElement_getDefault()

def SoLightModelElement_getInstance(state):
    """SoLightModelElement_getInstance(SoState state) -> SoLightModelElement"""
    return _coin.SoLightModelElement_getInstance(state)

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, state):
        """init(SoMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoMultiTextureCoordinateElement_init(self, state)


    def setDefault(state, node, unit):
        """setDefault(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureCoordinateElement_setDefault(state, node, unit)

    setDefault = staticmethod(setDefault)

    def set2(state, node, unit, numCoords, coords):
        """set2(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec2f coords)"""
        return _coin.SoMultiTextureCoordinateElement_set2(state, node, unit, numCoords, coords)

    set2 = staticmethod(set2)

    def set3(state, node, unit, numCoords, coords):
        """set3(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoMultiTextureCoordinateElement_set3(state, node, unit, numCoords, coords)

    set3 = staticmethod(set3)

    def set4(state, node, unit, numCoords, coords):
        """set4(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec4f coords)"""
        return _coin.SoMultiTextureCoordinateElement_set4(state, node, unit, numCoords, coords)

    set4 = staticmethod(set4)

    def getType(self, *args):
        """
        getType(SoMultiTextureCoordinateElement self, SoState state, int const unit) -> SoTextureCoordinateElement::CoordType
        getType(SoMultiTextureCoordinateElement self, int const unit) -> SoTextureCoordinateElement::CoordType
        """
        return _coin.SoMultiTextureCoordinateElement_getType(self, *args)


    def getInstance(state):
        """getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
        return _coin.SoMultiTextureCoordinateElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def get(self, unit, point, normal):
        """get(SoMultiTextureCoordinateElement self, int const unit, SbVec3f point, SbVec3f normal) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_get(self, unit, point, normal)


    def getNum(self, unit):
        """getNum(SoMultiTextureCoordinateElement self, int const unit) -> int32_t"""
        return _coin.SoMultiTextureCoordinateElement_getNum(self, unit)


    def is2D(self, unit):
        """is2D(SoMultiTextureCoordinateElement self, int const unit) -> SbBool"""
        return _coin.SoMultiTextureCoordinateElement_is2D(self, unit)


    def getDimension(self, unit):
        """getDimension(SoMultiTextureCoordinateElement self, int const unit) -> int32_t"""
        return _coin.SoMultiTextureCoordinateElement_getDimension(self, unit)


    def get2(self, unit, index):
        """get2(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec2f"""
        return _coin.SoMultiTextureCoordinateElement_get2(self, unit, index)


    def get3(self, unit, index):
        """get3(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec3f"""
        return _coin.SoMultiTextureCoordinateElement_get3(self, unit, index)


    def get4(self, unit, index):
        """get4(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_get4(self, unit, index)


    def getArrayPtr2(self, unit):
        """getArrayPtr2(SoMultiTextureCoordinateElement self, int const unit) -> SbVec2f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr2(self, unit)


    def getArrayPtr3(self, unit):
        """getArrayPtr3(SoMultiTextureCoordinateElement self, int const unit) -> SbVec3f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr3(self, unit)


    def getArrayPtr4(self, unit):
        """getArrayPtr4(SoMultiTextureCoordinateElement self, int const unit) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr4(self, unit)


    def push(self, state):
        """push(SoMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoMultiTextureCoordinateElement_push(self, state)


    def matches(self, elem):
        """matches(SoMultiTextureCoordinateElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureCoordinateElement_matches(self, elem)


    def copyMatchInfo(self):
        """copyMatchInfo(SoMultiTextureCoordinateElement 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(state, node, unit):
    """SoMultiTextureCoordinateElement_setDefault(SoState state, SoNode node, int const unit)"""
    return _coin.SoMultiTextureCoordinateElement_setDefault(state, node, unit)

def SoMultiTextureCoordinateElement_set2(state, node, unit, numCoords, coords):
    """SoMultiTextureCoordinateElement_set2(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec2f coords)"""
    return _coin.SoMultiTextureCoordinateElement_set2(state, node, unit, numCoords, coords)

def SoMultiTextureCoordinateElement_set3(state, node, unit, numCoords, coords):
    """SoMultiTextureCoordinateElement_set3(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec3f coords)"""
    return _coin.SoMultiTextureCoordinateElement_set3(state, node, unit, numCoords, coords)

def SoMultiTextureCoordinateElement_set4(state, node, unit, numCoords, coords):
    """SoMultiTextureCoordinateElement_set4(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec4f coords)"""
    return _coin.SoMultiTextureCoordinateElement_set4(state, node, unit, numCoords, coords)

def SoMultiTextureCoordinateElement_getInstance(state):
    """SoMultiTextureCoordinateElement_getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
    return _coin.SoMultiTextureCoordinateElement_getInstance(state)

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, state):
        """init(SoGLMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_init(self, state)


    def push(self, state):
        """push(SoGLMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLMultiTextureCoordinateElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureCoordinateElement_pop(self, state, prevTopElement)


    def getType(self, unit):
        """getType(SoGLMultiTextureCoordinateElement self, int const unit) -> SoTextureCoordinateElement::CoordType"""
        return _coin.SoGLMultiTextureCoordinateElement_getType(self, unit)


    def getInstance(state):
        """getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
        return _coin.SoGLMultiTextureCoordinateElement_getInstance(state)

    getInstance = staticmethod(getInstance)

    def send(self, *args):
        """
        send(SoGLMultiTextureCoordinateElement self, int const unit, int const index)
        send(SoGLMultiTextureCoordinateElement self, int const unit, int const index, SbVec3f c, SbVec3f n)
        """
        return _coin.SoGLMultiTextureCoordinateElement_send(self, *args)


    def initRender(self, enabled, maxenabled):
        """initRender(SoGLMultiTextureCoordinateElement self, SbBool const * enabled, int const maxenabled)"""
        return _coin.SoGLMultiTextureCoordinateElement_initRender(self, enabled, maxenabled)

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(state):
    """SoGLMultiTextureCoordinateElement_getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
    return _coin.SoGLMultiTextureCoordinateElement_getInstance(state)

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, state):
        """init(SoMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoMultiTextureEnabledElement_init(self, state)


    def set(state, node, unit, enabled):
        """set(SoState state, SoNode node, int const unit, SbBool const enabled)"""
        return _coin.SoMultiTextureEnabledElement_set(state, node, unit, enabled)

    set = staticmethod(set)

    def get(state, unit):
        """get(SoState state, int const unit) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_get(state, unit)

    get = staticmethod(get)

    def setElt(self, unit, mode):
        """setElt(SoMultiTextureEnabledElement self, int const unit, int const mode)"""
        return _coin.SoMultiTextureEnabledElement_setElt(self, unit, mode)


    def push(self, state):
        """push(SoMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoMultiTextureEnabledElement_push(self, state)


    def matches(self, elem):
        """matches(SoMultiTextureEnabledElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_matches(self, elem)


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


    def getEnabledUnits(state, lastenabled):
        """getEnabledUnits(SoState state, int & lastenabled) -> SbBool const *"""
        return _coin.SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled)

    getEnabledUnits = staticmethod(getEnabledUnits)

    def getActiveUnits(state, lastenabled):
        """getActiveUnits(SoState state, int & lastenabled) -> SoMultiTextureEnabledElement::Mode const *"""
        return _coin.SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled)

    getActiveUnits = staticmethod(getActiveUnits)

    def enableRectangle(state, node, unit):
        """enableRectangle(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureEnabledElement_enableRectangle(state, node, unit)

    enableRectangle = staticmethod(enableRectangle)

    def enableCubeMap(state, node, unit):
        """enableCubeMap(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureEnabledElement_enableCubeMap(state, node, unit)

    enableCubeMap = staticmethod(enableCubeMap)

    def getMode(state, unit):
        """getMode(SoState state, int const unit) -> SoMultiTextureEnabledElement::Mode"""
        return _coin.SoMultiTextureEnabledElement_getMode(state, unit)

    getMode = staticmethod(getMode)

    def disableAll(state):
        """disableAll(SoState state)"""
        return _coin.SoMultiTextureEnabledElement_disableAll(state)

    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(state, node, unit, enabled):
    """SoMultiTextureEnabledElement_set(SoState state, SoNode node, int const unit, SbBool const enabled)"""
    return _coin.SoMultiTextureEnabledElement_set(state, node, unit, enabled)

def SoMultiTextureEnabledElement_get(state, unit):
    """SoMultiTextureEnabledElement_get(SoState state, int const unit) -> SbBool"""
    return _coin.SoMultiTextureEnabledElement_get(state, unit)

def SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled):
    """SoMultiTextureEnabledElement_getEnabledUnits(SoState state, int & lastenabled) -> SbBool const *"""
    return _coin.SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled)

def SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled):
    """SoMultiTextureEnabledElement_getActiveUnits(SoState state, int & lastenabled) -> SoMultiTextureEnabledElement::Mode const *"""
    return _coin.SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled)

def SoMultiTextureEnabledElement_enableRectangle(state, node, unit):
    """SoMultiTextureEnabledElement_enableRectangle(SoState state, SoNode node, int const unit)"""
    return _coin.SoMultiTextureEnabledElement_enableRectangle(state, node, unit)

def SoMultiTextureEnabledElement_enableCubeMap(state, node, unit):
    """SoMultiTextureEnabledElement_enableCubeMap(SoState state, SoNode node, int const unit)"""
    return _coin.SoMultiTextureEnabledElement_enableCubeMap(state, node, unit)

def SoMultiTextureEnabledElement_getMode(state, unit):
    """SoMultiTextureEnabledElement_getMode(SoState state, int const unit) -> SoMultiTextureEnabledElement::Mode"""
    return _coin.SoMultiTextureEnabledElement_getMode(state, unit)

def SoMultiTextureEnabledElement_disableAll(state):
    """SoMultiTextureEnabledElement_disableAll(SoState state)"""
    return _coin.SoMultiTextureEnabledElement_disableAll(state)

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, state):
        """init(SoGLMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoGLMultiTextureEnabledElement_init(self, state)


    def push(self, state):
        """push(SoGLMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoGLMultiTextureEnabledElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLMultiTextureEnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureEnabledElement_pop(self, state, prevTopElement)


    def setElt(self, unit, mode):
        """setElt(SoGLMultiTextureEnabledElement self, int const unit, int const mode)"""
        return _coin.SoGLMultiTextureEnabledElement_setElt(self, unit, mode)

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, state):
        """init(SoMultiTextureImageElement self, SoState state)"""
        return _coin.SoMultiTextureImageElement_init(self, state)


    def setDefault(state, node, unit):
        """setDefault(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureImageElement_setDefault(state, node, unit)

    setDefault = staticmethod(setDefault)

    def set(*args):
        """
        set(SoState state, SoNode node, int const unit, SbVec2s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Model const model, SbColor blendColor)
        set(SoState state, SoNode node, int const unit, SbVec3s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Wrap const wrapR, SoTextureImageElement::Model const model, SbColor blendColor)
        """
        return _coin.SoMultiTextureImageElement_set(*args)

    set = staticmethod(set)

    def get(*args):
        """
        get(SoState state, int const unit, SbVec2s size, int & numComponents, SoTextureImageElement::Wrap & wrapS, SoTextureImageElement::Wrap & wrapT, SoTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
        get(SoState state, int const unit, SbVec3s size, int & numComponents, SoTextureImageElement::Wrap & wrapS, SoTextureImageElement::Wrap & wrapT, SoTextureImageElement::Wrap & wrapR, SoTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const *
        """
        return _coin.SoMultiTextureImageElement_get(*args)

    get = staticmethod(get)

    def getImage(*args):
        """
        getImage(SoState state, int const unit, SbVec2s size, int & numComponents) -> unsigned char const
        getImage(SoState state, int const unit, SbVec3s size, int & numComponents) -> unsigned char const *
        """
        return _coin.SoMultiTextureImageElement_getImage(*args)

    getImage = staticmethod(getImage)

    def getBlendColor(state, unit):
        """getBlendColor(SoState state, int const unit) -> SbColor"""
        return _coin.SoMultiTextureImageElement_getBlendColor(state, unit)

    getBlendColor = staticmethod(getBlendColor)

    def getModel(state, unit):
        """getModel(SoState state, int const unit) -> SoTextureImageElement::Model"""
        return _coin.SoMultiTextureImageElement_getModel(state, unit)

    getModel = staticmethod(getModel)

    def getWrapS(state, unit):
        """getWrapS(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapS(state, unit)

    getWrapS = staticmethod(getWrapS)

    def getWrapT(state, unit):
        """getWrapT(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapT(state, unit)

    getWrapT = staticmethod(getWrapT)

    def getWrapR(state, unit):
        """getWrapR(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapR(state, unit)

    getWrapR = staticmethod(getWrapR)

    def containsTransparency(state):
        """containsTransparency(SoState state) -> SbBool"""
        return _coin.SoMultiTextureImageElement_containsTransparency(state)

    containsTransparency = staticmethod(containsTransparency)

    def getDefault(*args):
        """
        getDefault(SbVec2s size, int & numComponents) -> unsigned char const
        getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
        """
        return _coin.SoMultiTextureImageElement_getDefault(*args)

    getDefault = staticmethod(getDefault)

    def push(self, state):
        """push(SoMultiTextureImageElement self, SoState state)"""
        return _coin.SoMultiTextureImageElement_push(self, state)


    def matches(self, elem):
        """matches(SoMultiTextureImageElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureImageElement_matches(self, elem)


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


    def setElt(self, *args):
        """
        setElt(SoMultiTextureImageElement self, int const unit, uint32_t const nodeid, SbVec2s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Model const model, SbColor blendColor)
        setElt(SoMultiTextureImageElement self, int const unit, uint32_t const nodeid, SbVec3s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Wrap const wrapR, SoTextureImageElement::Model const model, SbColor blendColor)
        """
        return _coin.SoMultiTextureImageElement_setElt(self, *args)


    def hasTransparency(self, unit):
        """hasTransparency(SoMultiTextureImageElement self, int const unit) -> SbBool"""
        return _coin.SoMultiTextureImageElement_hasTransparency(self, unit)

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(state, node, unit):
    """SoMultiTextureImageElement_setDefault(SoState state, SoNode node, int const unit)"""
    return _coin.SoMultiTextureImageElement_setDefault(state, node, unit)

def SoMultiTextureImageElement_set(*args):
    """
    set(SoState state, SoNode node, int const unit, SbVec2s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Model const model, SbColor blendColor)
    SoMultiTextureImageElement_set(SoState state, SoNode node, int const unit, SbVec3s size, int const numComponents, unsigned char const * bytes, SoTextureImageElement::Wrap const wrapS, SoTextureImageElement::Wrap const wrapT, SoTextureImageElement::Wrap const wrapR, SoTextureImageElement::Model const model, SbColor blendColor)
    """
    return _coin.SoMultiTextureImageElement_set(*args)

def SoMultiTextureImageElement_get(*args):
    """
    get(SoState state, int const unit, SbVec2s size, int & numComponents, SoTextureImageElement::Wrap & wrapS, SoTextureImageElement::Wrap & wrapT, SoTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
    SoMultiTextureImageElement_get(SoState state, int const unit, SbVec3s size, int & numComponents, SoTextureImageElement::Wrap & wrapS, SoTextureImageElement::Wrap & wrapT, SoTextureImageElement::Wrap & wrapR, SoTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const *
    """
    return _coin.SoMultiTextureImageElement_get(*args)

def SoMultiTextureImageElement_getImage(*args):
    """
    getImage(SoState state, int const unit, SbVec2s size, int & numComponents) -> unsigned char const
    SoMultiTextureImageElement_getImage(SoState state, int const unit, SbVec3s size, int & numComponents) -> unsigned char const *
    """
    return _coin.SoMultiTextureImageElement_getImage(*args)

def SoMultiTextureImageElement_getBlendColor(state, unit):
    """SoMultiTextureImageElement_getBlendColor(SoState state, int const unit) -> SbColor"""
    return _coin.SoMultiTextureImageElement_getBlendColor(state, unit)

def SoMultiTextureImageElement_getModel(state, unit):
    """SoMultiTextureImageElement_getModel(SoState state, int const unit) -> SoTextureImageElement::Model"""
    return _coin.SoMultiTextureImageElement_getModel(state, unit)

def SoMultiTextureImageElement_getWrapS(state, unit):
    """SoMultiTextureImageElement_getWrapS(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
    return _coin.SoMultiTextureImageElement_getWrapS(state, unit)

def SoMultiTextureImageElement_getWrapT(state, unit):
    """SoMultiTextureImageElement_getWrapT(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
    return _coin.SoMultiTextureImageElement_getWrapT(state, unit)

def SoMultiTextureImageElement_getWrapR(state, unit):
    """SoMultiTextureImageElement_getWrapR(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
    return _coin.SoMultiTextureImageElement_getWrapR(state, unit)

def SoMultiTextureImageElement_containsTransparency(state):
    """SoMultiTextureImageElement_containsTransparency(SoState state) -> SbBool"""
    return _coin.SoMultiTextureImageElement_containsTransparency(state)

def SoMultiTextureImageElement_getDefault(*args):
    """
    getDefault(SbVec2s size, int & numComponents) -> unsigned char const
    SoMultiTextureImageElement_getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
    """
    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, state):
        """init(SoGLMultiTextureImageElement self, SoState state)"""
        return _coin.SoGLMultiTextureImageElement_init(self, state)


    def push(self, state):
        """push(SoGLMultiTextureImageElement self, SoState state)"""
        return _coin.SoGLMultiTextureImageElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLMultiTextureImageElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureImageElement_pop(self, state, prevTopElement)


    def set(state, node, unit, image, model, blendColor):
        """set(SoState state, SoNode node, int const unit, SoGLImage image, SoTextureImageElement::Model const model, SbColor blendColor)"""
        return _coin.SoGLMultiTextureImageElement_set(state, node, unit, image, model, blendColor)

    set = staticmethod(set)

    def restore(state, unit):
        """restore(SoState state, int const unit)"""
        return _coin.SoGLMultiTextureImageElement_restore(state, unit)

    restore = staticmethod(restore)

    def get(state, unit, model, blendcolor):
        """get(SoState state, int const unit, SoTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage"""
        return _coin.SoGLMultiTextureImageElement_get(state, unit, model, blendcolor)

    get = staticmethod(get)

    def hasTransparency(state):
        """hasTransparency(SoState state) -> SbBool"""
        return _coin.SoGLMultiTextureImageElement_hasTransparency(state)

    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(state, node, unit, image, model, blendColor):
    """SoGLMultiTextureImageElement_set(SoState state, SoNode node, int const unit, SoGLImage image, SoTextureImageElement::Model const model, SbColor blendColor)"""
    return _coin.SoGLMultiTextureImageElement_set(state, node, unit, image, model, blendColor)

def SoGLMultiTextureImageElement_restore(state, unit):
    """SoGLMultiTextureImageElement_restore(SoState state, int const unit)"""
    return _coin.SoGLMultiTextureImageElement_restore(state, unit)

def SoGLMultiTextureImageElement_get(state, unit, model, blendcolor):
    """SoGLMultiTextureImageElement_get(SoState state, int const unit, SoTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage"""
    return _coin.SoGLMultiTextureImageElement_get(state, unit, model, blendcolor)

def SoGLMultiTextureImageElement_hasTransparency(state):
    """SoGLMultiTextureImageElement_hasTransparency(SoState state) -> SbBool"""
    return _coin.SoGLMultiTextureImageElement_hasTransparency(state)

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, state):
        """init(SoMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoMultiTextureMatrixElement_init(self, state)


    def push(self, state):
        """push(SoMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoMultiTextureMatrixElement_push(self, state)


    def set(state, node, unit):
        """set(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureMatrixElement_set(state, node, unit)

    set = staticmethod(set)

    def mult(state, node, unit):
        """mult(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureMatrixElement_mult(state, node, unit)

    mult = staticmethod(mult)

    def get(state, unit):
        """get(SoState state, int const unit) -> SbMatrix"""
        return _coin.SoMultiTextureMatrixElement_get(state, unit)

    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(state, node, unit):
    """SoMultiTextureMatrixElement_set(SoState state, SoNode node, int const unit)"""
    return _coin.SoMultiTextureMatrixElement_set(state, node, unit)

def SoMultiTextureMatrixElement_mult(state, node, unit):
    """SoMultiTextureMatrixElement_mult(SoState state, SoNode node, int const unit)"""
    return _coin.SoMultiTextureMatrixElement_mult(state, node, unit)

def SoMultiTextureMatrixElement_get(state, unit):
    """SoMultiTextureMatrixElement_get(SoState state, int const unit) -> SbMatrix"""
    return _coin.SoMultiTextureMatrixElement_get(state, unit)

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, state):
        """init(SoGLMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoGLMultiTextureMatrixElement_init(self, state)


    def push(self, state):
        """push(SoGLMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoGLMultiTextureMatrixElement_push(self, state)


    def pop(self, state, prevTopElement):
        """pop(SoGLMultiTextureMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureMatrixElement_pop(self, state, prevTopElement)


    def multElt(self, unit):
        """multElt(SoGLMultiTextureMatrixElement self, int const unit)"""
        return _coin.SoGLMultiTextureMatrixElement_multElt(self, unit)


    def setElt(self, unit):
        """setElt(SoGLMultiTextureMatrixElement self, int const unit)"""
        return _coin.SoGLMultiTextureMatrixElement_setElt(self, unit)

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__(SbColor4f self) -> SbColor4f
        __init__(SbColor4f self, SbColor rgb, float const alpha) -> SbColor4f
        __init__(SbColor4f self, SbVec4f v) -> SbColor4f
        __init__(SbColor4f self, float const *const rgba) -> SbColor4f
        __init__(SbColor4f self, float const r, float const g, float const b, float const a=1.0) -> SbColor4f
        __init__(SbColor4f self, float const r, float const g, float const b) -> SbColor4f
        """
        this = _coin.new_SbColor4f(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbColor4f self, float const r, float const g, float const b, float const a=1.0)
        setValue(SbColor4f self, float const r, float const g, float const b)
        setValue(SbColor4f self, float const [4] col)
        """
        return _coin.SbColor4f_setValue(self, *args)


    def getValue(self):
        """getValue(SbColor4f self)"""
        return _coin.SbColor4f_getValue(self)


    def setRGB(self, col):
        """setRGB(SbColor4f self, SbColor col) -> SbColor4f"""
        return _coin.SbColor4f_setRGB(self, col)


    def getRGB(self, color):
        """getRGB(SbColor4f self, SbColor color)"""
        return _coin.SbColor4f_getRGB(self, color)


    def setHSVValue(self, *args):
        """
        setHSVValue(SbColor4f self, float h, float s, float v, float a=1.0) -> SbColor4f
        setHSVValue(SbColor4f self, float h, float s, float v) -> SbColor4f
        setHSVValue(SbColor4f self, float const [3] hsv, float alpha=1.0) -> SbColor4f
        setHSVValue(SbColor4f self, float const [3] hsv) -> SbColor4f
        """
        return _coin.SbColor4f_setHSVValue(self, *args)


    def getHSVValue(self):
        """getHSVValue(SbColor4f self)"""
        return _coin.SbColor4f_getHSVValue(self)


    def setPackedValue(self, rgba):
        """setPackedValue(SbColor4f self, uint32_t const rgba) -> SbColor4f"""
        return _coin.SbColor4f_setPackedValue(self, rgba)


    def getPackedValue(self):
        """getPackedValue(SbColor4f self) -> uint32_t"""
        return _coin.SbColor4f_getPackedValue(self)


    def __imul__(self, d):
        """__imul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___imul__(self, d)


    def __idiv__(self, d):
        """__idiv__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___idiv__(self, d)


    def __iadd__(self, c):
        """__iadd__(SbColor4f self, SbColor4f c) -> SbColor4f"""
        return _coin.SbColor4f___iadd__(self, c)


    def __isub__(self, c):
        """__isub__(SbColor4f self, SbColor4f c) -> SbColor4f"""
        return _coin.SbColor4f___isub__(self, c)


    def __add__(self, u):
        """__add__(SbColor4f self, SbColor4f u) -> SbColor4f"""
        return _coin.SbColor4f___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbColor4f self, SbColor4f u) -> SbColor4f"""
        return _coin.SbColor4f___sub__(self, u)


    def __mul__(self, d):
        """__mul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___mul__(self, d)


    def __rmul__(self, d):
        """__rmul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbColor4f self, SbColor4f u) -> int"""
        return _coin.SbColor4f___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbColor4f self, SbColor4f u) -> int"""
        return _coin.SbColor4f___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbColor4f self, int i) -> float"""
        return _coin.SbColor4f___getitem__(self, i)

    __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, state):
        """init(SoTextureCombineElement self, SoState state)"""
        return _coin.SoTextureCombineElement_init(self, state)


    def set(state, node, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale):
        """set(SoState state, SoNode node, int const unit, SoTextureCombineElement::Operation const rgboperation, SoTextureCombineElement::Operation const alphaoperation, SoTextureCombineElement::Source const * rgbsource, SoTextureCombineElement::Source const * alphasource, SoTextureCombineElement::Operand const * rgboperand, SoTextureCombineElement::Operand const * alphaoperand, SbColor4f constantcolor, float const rgbscale, float const alphascale)"""
        return _coin.SoTextureCombineElement_set(state, node, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

    set = staticmethod(set)

    def isDefault(state, unit):
        """isDefault(SoState state, int const unit) -> SbBool"""
        return _coin.SoTextureCombineElement_isDefault(state, unit)

    isDefault = staticmethod(isDefault)

    def get(state, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale):
        """get(SoState state, int const unit, SoTextureCombineElement::Operation & rgboperation, SoTextureCombineElement::Operation & alphaoperation, SoTextureCombineElement::Source * rgbsource, SoTextureCombineElement::Source * alphasource, SoTextureCombineElement::Operand * rgboperand, SoTextureCombineElement::Operand * alphaoperand, SbColor4f constantcolor, float & rgbscale, float & alphascale)"""
        return _coin.SoTextureCombineElement_get(state, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

    get = staticmethod(get)

    def push(self, state):
        """push(SoTextureCombineElement self, SoState state)"""
        return _coin.SoTextureCombineElement_push(self, state)


    def matches(self, elem):
        """matches(SoTextureCombineElement self, SoElement elem) -> SbBool"""
        return _coin.SoTextureCombineElement_matches(self, elem)


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


    def setElt(self, unit, nodeid, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale):
        """setElt(SoTextureCombineElement self, int const unit, uint32_t const nodeid, SoTextureCombineElement::Operation const rgboperation, SoTextureCombineElement::Operation const alphaoperation, SoTextureCombineElement::Source const * rgbsource, SoTextureCombineElement::Source const * alphasource, SoTextureCombineElement::Operand const * rgboperand, SoTextureCombineElement::Operand const * alphaoperand, SbColor4f constantcolor, float const rgbscale, float const alphascale)"""
        return _coin.SoTextureCombineElement_setElt(self, unit, nodeid, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)


    def apply(state, unit):
        """apply(SoState state, int const unit)"""
        return _coin.SoTextureCombineElement_apply(state, unit)

    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(state, node, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale):
    """SoTextureCombineElement_set(SoState state, SoNode node, int const unit, SoTextureCombineElement::Operation const rgboperation, SoTextureCombineElement::Operation const alphaoperation, SoTextureCombineElement::Source const * rgbsource, SoTextureCombineElement::Source const * alphasource, SoTextureCombineElement::Operand const * rgboperand, SoTextureCombineElement::Operand const * alphaoperand, SbColor4f constantcolor, float const rgbscale, float const alphascale)"""
    return _coin.SoTextureCombineElement_set(state, node, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

def SoTextureCombineElement_isDefault(state, unit):
    """SoTextureCombineElement_isDefault(SoState state, int const unit) -> SbBool"""
    return _coin.SoTextureCombineElement_isDefault(state, unit)

def SoTextureCombineElement_get(state, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale):
    """SoTextureCombineElement_get(SoState state, int const unit, SoTextureCombineElement::Operation & rgboperation, SoTextureCombineElement::Operation & alphaoperation, SoTextureCombineElement::Source * rgbsource, SoTextureCombineElement::Source * alphasource, SoTextureCombineElement::Operand * rgboperand, SoTextureCombineElement::Operand * alphaoperand, SbColor4f constantcolor, float & rgbscale, float & alphascale)"""
    return _coin.SoTextureCombineElement_get(state, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale)

def SoTextureCombineElement_apply(state, unit):
    """SoTextureCombineElement_apply(SoState state, int const unit)"""
    return _coin.SoTextureCombineElement_apply(state, unit)

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, state):
        """init(SoTextureUnitElement self, SoState state)"""
        return _coin.SoTextureUnitElement_init(self, state)


    def set(state, node, units):
        """set(SoState state, SoNode node, int const units)"""
        return _coin.SoTextureUnitElement_set(state, node, units)

    set = staticmethod(set)

    def get(state):
        """get(SoState state) -> int"""
        return _coin.SoTextureUnitElement_get(state)

    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(state, node, units):
    """SoTextureUnitElement_set(SoState state, SoNode node, int const units)"""
    return _coin.SoTextureUnitElement_set(state, node, units)

def SoTextureUnitElement_get(state):
    """SoTextureUnitElement_get(SoState state) -> int"""
    return _coin.SoTextureUnitElement_get(state)

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(SoEngine self)"""
        return _coin.SoEngine_evaluateWrapper(self)


    def getOutputs(self, l):
        """getOutputs(SoEngine self, SoEngineOutputList l) -> int"""
        return _coin.SoEngine_getOutputs(self, l)


    def getOutput(self, outputname):
        """getOutput(SoEngine self, SbName outputname) -> SoEngineOutput"""
        return _coin.SoEngine_getOutput(self, outputname)


    def getOutputName(self, output, outputname):
        """getOutputName(SoEngine self, SoEngineOutput output, SbName outputname) -> SbBool"""
        return _coin.SoEngine_getOutputName(self, output, outputname)


    def getOutputData(self):
        """getOutputData(SoEngine 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(SoEngine self) -> SbBool"""
        return _coin.SoEngine_isNotifying(self)


    def notify(self, nl):
        """notify(SoEngine self, SoNotList nl)"""
        return _coin.SoEngine_notify(self, nl)


    def copy(self):
        """copy(SoEngine self) -> SoEngine"""
        return _coin.SoEngine_copy(self)


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


    def shouldCopy(self):
        """shouldCopy(SoEngine self) -> SbBool"""
        return _coin.SoEngine_shouldCopy(self)


    def writeInstance(self, out):
        """writeInstance(SoEngine self, SoOutput out)"""
        return _coin.SoEngine_writeInstance(self, out)



    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__(SoEngineOutput 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(SoEngineOutput self) -> SoType"""
        return _coin.SoEngineOutput_getConnectionType(self)


    def getForwardConnections(self, fl):
        """getForwardConnections(SoEngineOutput self, SoFieldList fl) -> int"""
        return _coin.SoEngineOutput_getForwardConnections(self, fl)


    def enable(self, flag):
        """enable(SoEngineOutput self, SbBool const flag)"""
        return _coin.SoEngineOutput_enable(self, flag)


    def isEnabled(self):
        """isEnabled(SoEngineOutput self) -> SbBool"""
        return _coin.SoEngineOutput_isEnabled(self)


    def getContainer(self):
        """getContainer(SoEngineOutput self) -> SoEngine"""
        return _coin.SoEngineOutput_getContainer(self)


    def getNodeContainer(self):
        """getNodeContainer(SoEngineOutput self) -> SoNodeEngine"""
        return _coin.SoEngineOutput_getNodeContainer(self)


    def isNodeEngineOutput(self):
        """isNodeEngineOutput(SoEngineOutput self) -> SbBool"""
        return _coin.SoEngineOutput_isNodeEngineOutput(self)


    def setContainer(self, engine):
        """setContainer(SoEngineOutput self, SoEngine engine)"""
        return _coin.SoEngineOutput_setContainer(self, engine)


    def setNodeContainer(self, nodeengine):
        """setNodeContainer(SoEngineOutput self, SoNodeEngine nodeengine)"""
        return _coin.SoEngineOutput_setNodeContainer(self, nodeengine)


    def addConnection(self, f):
        """addConnection(SoEngineOutput self, SoField f)"""
        return _coin.SoEngineOutput_addConnection(self, f)


    def removeConnection(self, f):
        """removeConnection(SoEngineOutput self, SoField f)"""
        return _coin.SoEngineOutput_removeConnection(self, f)


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


    def prepareToWrite(self):
        """prepareToWrite(SoEngineOutput self)"""
        return _coin.SoEngineOutput_prepareToWrite(self)


    def doneWriting(self):
        """doneWriting(SoEngineOutput self)"""
        return _coin.SoEngineOutput_doneWriting(self)


    def touchSlaves(self, nl, donotify):
        """touchSlaves(SoEngineOutput self, SoNotList nl, SbBool donotify)"""
        return _coin.SoEngineOutput_touchSlaves(self, nl, donotify)


    def getFieldContainer(self):
        """getFieldContainer(SoEngineOutput 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__(SoEngineOutputData self) -> SoEngineOutputData
        __init__(SoEngineOutputData self, SoEngineOutputData data) -> SoEngineOutputData
        __init__(SoEngineOutputData 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(SoEngineOutputData self, SoEngine base, char const * name, SoEngineOutput output, SoType type)
        addOutput(SoEngineOutputData self, SoNodeEngine base, char const * name, SoEngineOutput output, SoType type)
        """
        return _coin.SoEngineOutputData_addOutput(self, *args)


    def getNumOutputs(self):
        """getNumOutputs(SoEngineOutputData self) -> int"""
        return _coin.SoEngineOutputData_getNumOutputs(self)


    def getOutputName(self, index):
        """getOutputName(SoEngineOutputData self, int index) -> SbName"""
        return _coin.SoEngineOutputData_getOutputName(self, index)


    def getOutput(self, *args):
        """
        getOutput(SoEngineOutputData self, SoEngine engine, int index) -> SoEngineOutput
        getOutput(SoEngineOutputData self, SoNodeEngine engine, int index) -> SoEngineOutput
        """
        return _coin.SoEngineOutputData_getOutput(self, *args)


    def getIndex(self, *args):
        """
        getIndex(SoEngineOutputData self, SoEngine engine, SoEngineOutput output) -> int
        getIndex(SoEngineOutputData self, SoNodeEngine engine, SoEngineOutput output) -> int
        """
        return _coin.SoEngineOutputData_getIndex(self, *args)


    def getType(self, index):
        """getType(SoEngineOutputData self, int index) -> SoType"""
        return _coin.SoEngineOutputData_getType(self, index)


    def readDescriptions(self, input, engine):
        """readDescriptions(SoEngineOutputData self, SoInput input, SoEngine engine) -> SbBool"""
        return _coin.SoEngineOutputData_readDescriptions(self, input, engine)


    def writeDescriptions(self, out, engine):
        """writeDescriptions(SoEngineOutputData self, SoOutput out, SoEngine engine)"""
        return _coin.SoEngineOutputData_writeDescriptions(self, out, engine)

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__(SoMFBool 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(SoMFBool self) -> SoType"""
        return _coin.SoMFBool_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFBool self, SoField field)"""
        return _coin.SoMFBool_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFBool self, SoField field) -> SbBool"""
        return _coin.SoMFBool_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFBool self, SbBool value, SbBool addifnotfound=0) -> int
        find(SoMFBool self, SbBool value) -> int
        """
        return _coin.SoMFBool_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFBool self, int const idx, SbBool value)"""
        return _coin.SoMFBool_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFBool self, SoMFBool field) -> SbBool"""
        return _coin.SoMFBool___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFBool self, SoMFBool field) -> SbBool"""
        return _coin.SoMFBool___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFBool self) -> SbBool *"""
        return _coin.SoMFBool_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFBool self)"""
        return _coin.SoMFBool_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFBool self, int const num, SbBool const * userdata)
        setValuesPointer(SoMFBool self, int const num, SbBool * userdata)
        """
        return _coin.SoMFBool_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoMFBool self, SbBool value)
        setValue(SoMFBool self, SoMFBool other)
        """
        return _coin.SoMFBool_setValue(self, *args)


    def __getitem__(self, i):
        """__getitem__(SoMFBool self, int i) -> SbBool const"""
        return _coin.SoMFBool___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFBool self, int i, SbBool value)"""
        return _coin.SoMFBool___setitem__(self, i, value)


    def getValues(self, i=0):
        """
        getValues(SoMFBool self, int i=0) -> SbBool const
        getValues(SoMFBool self) -> SbBool const *
        """
        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__(SoMFEnum 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(SoMFEnum self) -> SoType"""
        return _coin.SoMFEnum_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFEnum self, SoField field)"""
        return _coin.SoMFEnum_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFEnum self, SoField field) -> SbBool"""
        return _coin.SoMFEnum_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFEnum self, int value, SbBool addifnotfound=0) -> int
        find(SoMFEnum self, int value) -> int
        """
        return _coin.SoMFEnum_find(self, value, addifnotfound)


    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, field):
        """__eq__(SoMFEnum self, SoMFEnum field) -> SbBool"""
        return _coin.SoMFEnum___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFEnum self, SoMFEnum field) -> SbBool"""
        return _coin.SoMFEnum___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFEnum self) -> int *"""
        return _coin.SoMFEnum_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFEnum self)"""
        return _coin.SoMFEnum_finishEditing(self)


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

    initClass = staticmethod(initClass)

    def set1Value(self, *args):
        """
        set1Value(SoMFEnum self, int const idx, int value)
        set1Value(SoMFEnum self, int const idx, SbName name)
        """
        return _coin.SoMFEnum_set1Value(self, *args)


    def setEnums(self, num, values, names):
        """setEnums(SoMFEnum self, int const num, int const *const values, SbName names)"""
        return _coin.SoMFEnum_setEnums(self, num, values, names)


    def getNumEnums(self):
        """getNumEnums(SoMFEnum self) -> int"""
        return _coin.SoMFEnum_getNumEnums(self)


    def getEnum(self, idx, name):
        """getEnum(SoMFEnum self, int const idx, SbName name) -> int"""
        return _coin.SoMFEnum_getEnum(self, idx, name)


    def __getitem__(self, i):
        """__getitem__(SoMFEnum self, int i) -> int const"""
        return _coin.SoMFEnum___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFEnum self, int i, int value)"""
        return _coin.SoMFEnum___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFEnum self, int value)
        setValue(SoMFEnum self, SbName name)
        setValue(SoMFEnum self, SoMFEnum other)
        """
        return _coin.SoMFEnum_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFEnum self, int i=0) -> int const
        getValues(SoMFEnum self) -> int const *
        """
        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(SoBoolOperation self) -> SoType"""
        return _coin.SoBoolOperation_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoBoolOperation 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__(SoBoolOperation 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__(SoMFFloat 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(SoMFFloat self) -> SoType"""
        return _coin.SoMFFloat_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFFloat self, SoField field)"""
        return _coin.SoMFFloat_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFFloat self, SoField field) -> SbBool"""
        return _coin.SoMFFloat_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFFloat self, float value, SbBool addifnotfound=0) -> int
        find(SoMFFloat self, float value) -> int
        """
        return _coin.SoMFFloat_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFFloat self, int const idx, float value)"""
        return _coin.SoMFFloat_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFFloat self, SoMFFloat field) -> SbBool"""
        return _coin.SoMFFloat___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFFloat self, SoMFFloat field) -> SbBool"""
        return _coin.SoMFFloat___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFFloat self) -> float *"""
        return _coin.SoMFFloat_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFFloat self)"""
        return _coin.SoMFFloat_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFFloat self, int const num, float const * userdata)
        setValuesPointer(SoMFFloat self, int const num, float * userdata)
        """
        return _coin.SoMFFloat_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def __getitem__(self, i):
        """__getitem__(SoMFFloat self, int i) -> float const"""
        return _coin.SoMFFloat___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFFloat self, int i, float value)"""
        return _coin.SoMFFloat___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFFloat self, float value)
        setValue(SoMFFloat self, SoMFFloat other)
        """
        return _coin.SoMFFloat_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFFloat self, int i=0) -> float const
        getValues(SoMFFloat self) -> float const *
        """
        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__(SoMFVec3f 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(SoMFVec3f self) -> SoType"""
        return _coin.SoMFVec3f_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec3f self, SoField field)"""
        return _coin.SoMFVec3f_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec3f self, SoField field) -> SbBool"""
        return _coin.SoMFVec3f_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec3f self, SbVec3f value, SbBool addifnotfound=0) -> int
        find(SoMFVec3f self, SbVec3f value) -> int
        """
        return _coin.SoMFVec3f_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec3f self, SoMFVec3f field) -> SbBool"""
        return _coin.SoMFVec3f___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec3f self, SoMFVec3f field) -> SbBool"""
        return _coin.SoMFVec3f___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec3f self) -> SbVec3f"""
        return _coin.SoMFVec3f_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec3f self)"""
        return _coin.SoMFVec3f_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec3f self, int const num, SbVec3f userdata)
        setValuesPointer(SoMFVec3f self, int const num, SbVec3f userdata)
        setValuesPointer(SoMFVec3f self, int const num, float const * userdata)
        setValuesPointer(SoMFVec3f self, int const 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(SoMFVec3f self, int const idx, SbVec3f value)
        set1Value(SoMFVec3f self, int idx, float x, float y, float z)
        set1Value(SoMFVec3f self, int idx, float const [3] xyz)
        """
        return _coin.SoMFVec3f_set1Value(self, *args)


    def __getitem__(self, i):
        """__getitem__(SoMFVec3f self, int i) -> SbVec3f"""
        return _coin.SoMFVec3f___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFVec3f self, int i, SbVec3f value)"""
        return _coin.SoMFVec3f___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFVec3f self, SbVec3f value)
        setValue(SoMFVec3f self, float x, float y, float z)
        setValue(SoMFVec3f self, float const [3] xyz)
        setValue(SoMFVec3f self, SoMFVec3f other)
        """
        return _coin.SoMFVec3f_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFVec3f self, int i=0) -> SbVec3f
        getValues(SoMFVec3f 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__(SoMFString 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(SoMFString self) -> SoType"""
        return _coin.SoMFString_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFString self, SoField field)"""
        return _coin.SoMFString_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFString self, SoField field) -> SbBool"""
        return _coin.SoMFString_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFString self, SbString value, SbBool addifnotfound=0) -> int
        find(SoMFString self, SbString value) -> int
        """
        return _coin.SoMFString_find(self, value, addifnotfound)


    def set1Value(self, idx, value):
        """set1Value(SoMFString self, int const idx, SbString value)"""
        return _coin.SoMFString_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFString self, SoMFString field) -> SbBool"""
        return _coin.SoMFString___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFString self, SoMFString field) -> SbBool"""
        return _coin.SoMFString___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFString self) -> SbString"""
        return _coin.SoMFString_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFString 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, fromline, fromchar, toline, tochar):
        """deleteText(SoMFString self, int const fromline, int const fromchar, int const toline, int const tochar)"""
        return _coin.SoMFString_deleteText(self, fromline, fromchar, toline, tochar)


    def __getitem__(self, i):
        """__getitem__(SoMFString self, int i) -> SbString"""
        return _coin.SoMFString___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFString self, int i, SbString value)"""
        return _coin.SoMFString___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFString self, SbString value)
        setValue(SoMFString self, char const * string)
        setValue(SoMFString self, SoMFString other)
        """
        return _coin.SoMFString_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFString self, int i=0) -> SbString
        getValues(SoMFString 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(SoCalculator self) -> SoType"""
        return _coin.SoCalculator_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoCalculator 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__(SoCalculator 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__(SoMFVec2f 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(SoMFVec2f self) -> SoType"""
        return _coin.SoMFVec2f_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec2f self, SoField field)"""
        return _coin.SoMFVec2f_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec2f self, SoField field) -> SbBool"""
        return _coin.SoMFVec2f_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec2f self, SbVec2f value, SbBool addifnotfound=0) -> int
        find(SoMFVec2f self, SbVec2f value) -> int
        """
        return _coin.SoMFVec2f_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec2f self, SoMFVec2f field) -> SbBool"""
        return _coin.SoMFVec2f___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec2f self, SoMFVec2f field) -> SbBool"""
        return _coin.SoMFVec2f___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec2f self) -> SbVec2f"""
        return _coin.SoMFVec2f_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec2f self)"""
        return _coin.SoMFVec2f_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec2f self, int const num, SbVec2f userdata)
        setValuesPointer(SoMFVec2f self, int const num, SbVec2f userdata)
        setValuesPointer(SoMFVec2f self, int const num, float const * userdata)
        setValuesPointer(SoMFVec2f self, int const 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(SoMFVec2f self, int const idx, SbVec2f value)
        set1Value(SoMFVec2f self, int idx, float x, float y)
        set1Value(SoMFVec2f self, int idx, float const [2] xy)
        """
        return _coin.SoMFVec2f_set1Value(self, *args)


    def __getitem__(self, i):
        """__getitem__(SoMFVec2f self, int i) -> SbVec2f"""
        return _coin.SoMFVec2f___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFVec2f self, int i, SbVec2f value)"""
        return _coin.SoMFVec2f___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFVec2f self, SbVec2f value)
        setValue(SoMFVec2f self, float x, float y)
        setValue(SoMFVec2f self, float const [2] xy)
        setValue(SoMFVec2f self, SoMFVec2f other)
        """
        return _coin.SoMFVec2f_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFVec2f self, int i=0) -> SbVec2f
        getValues(SoMFVec2f 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(SoComposeVec2f self) -> SoType"""
        return _coin.SoComposeVec2f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoComposeVec2f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec2f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoComposeVec2f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoComposeVec2f 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(SoComposeVec3f self) -> SoType"""
        return _coin.SoComposeVec3f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoComposeVec3f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec3f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoComposeVec3f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoComposeVec3f 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__(SoMFVec4f 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(SoMFVec4f self) -> SoType"""
        return _coin.SoMFVec4f_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec4f self, SoField field)"""
        return _coin.SoMFVec4f_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec4f self, SoField field) -> SbBool"""
        return _coin.SoMFVec4f_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec4f self, SbVec4f value, SbBool addifnotfound=0) -> int
        find(SoMFVec4f self, SbVec4f value) -> int
        """
        return _coin.SoMFVec4f_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec4f self, SoMFVec4f field) -> SbBool"""
        return _coin.SoMFVec4f___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec4f self, SoMFVec4f field) -> SbBool"""
        return _coin.SoMFVec4f___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec4f self) -> SbVec4f"""
        return _coin.SoMFVec4f_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec4f self)"""
        return _coin.SoMFVec4f_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec4f self, int const num, SbVec4f userdata)
        setValuesPointer(SoMFVec4f self, int const num, SbVec4f userdata)
        setValuesPointer(SoMFVec4f self, int const num, float const * userdata)
        setValuesPointer(SoMFVec4f self, int const 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(SoMFVec4f self, int const idx, SbVec4f value)
        set1Value(SoMFVec4f self, int idx, float x, float y, float z, float w)
        set1Value(SoMFVec4f self, int idx, float const [4] xyzw)
        """
        return _coin.SoMFVec4f_set1Value(self, *args)


    def __getitem__(self, i):
        """__getitem__(SoMFVec4f self, int i) -> SbVec4f"""
        return _coin.SoMFVec4f___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFVec4f self, int i, SbVec4f value)"""
        return _coin.SoMFVec4f___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFVec4f self, SbVec4f value)
        setValue(SoMFVec4f self, float x, float y, float z, float w)
        setValue(SoMFVec4f self, float const [4] xyzw)
        setValue(SoMFVec4f self, SoMFVec4f other)
        """
        return _coin.SoMFVec4f_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFVec4f self, int i=0) -> SbVec4f
        getValues(SoMFVec4f 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(SoComposeVec4f self) -> SoType"""
        return _coin.SoComposeVec4f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoComposeVec4f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec4f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoComposeVec4f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoComposeVec4f 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(SoDecomposeVec2f self) -> SoType"""
        return _coin.SoDecomposeVec2f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoDecomposeVec2f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec2f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoDecomposeVec2f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoDecomposeVec2f 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(SoDecomposeVec3f self) -> SoType"""
        return _coin.SoDecomposeVec3f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoDecomposeVec3f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec3f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoDecomposeVec3f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoDecomposeVec3f 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(SoDecomposeVec4f self) -> SoType"""
        return _coin.SoDecomposeVec4f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoDecomposeVec4f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec4f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoDecomposeVec4f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoDecomposeVec4f 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(SoComposeRotation self) -> SoType"""
        return _coin.SoComposeRotation_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoComposeRotation self) -> SoEngineOutputData"""
        return _coin.SoComposeRotation_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoComposeRotation_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoComposeRotation 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__(SoMFRotation 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(SoMFRotation self) -> SoType"""
        return _coin.SoMFRotation_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFRotation self, SoField field)"""
        return _coin.SoMFRotation_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFRotation self, SoField field) -> SbBool"""
        return _coin.SoMFRotation_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFRotation self, SbRotation value, SbBool addifnotfound=0) -> int
        find(SoMFRotation self, SbRotation value) -> int
        """
        return _coin.SoMFRotation_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFRotation self, SoMFRotation field) -> SbBool"""
        return _coin.SoMFRotation___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFRotation self, SoMFRotation field) -> SbBool"""
        return _coin.SoMFRotation___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFRotation self) -> SbRotation"""
        return _coin.SoMFRotation_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFRotation 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(SoMFRotation self, int const idx, SbRotation value)
        set1Value(SoMFRotation self, int const idx, float const q0, float const q1, float const q2, float const q3)
        set1Value(SoMFRotation self, int const idx, float const [4] q)
        set1Value(SoMFRotation self, int const idx, SbVec3f axis, float const angle)
        """
        return _coin.SoMFRotation_set1Value(self, *args)


    def __getitem__(self, i):
        """__getitem__(SoMFRotation self, int i) -> SbRotation"""
        return _coin.SoMFRotation___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFRotation self, int i, SbRotation value)"""
        return _coin.SoMFRotation___setitem__(self, i, value)


    def getValues(self, i=0):
        """
        getValues(SoMFRotation self, int i=0) -> SbRotation
        getValues(SoMFRotation self) -> SbRotation
        """
        return _coin.SoMFRotation_getValues(self, i)


    def setValue(self, *args):
        """
        setValue(SoMFRotation self, SbRotation value)
        setValue(SoMFRotation self, float const q0, float const q1, float const q2, float const q3)
        setValue(SoMFRotation self, float const [4] q)
        setValue(SoMFRotation self, SbVec3f axis, float const angle)
        setValue(SoMFRotation 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(SoDecomposeRotation self) -> SoType"""
        return _coin.SoDecomposeRotation_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoDecomposeRotation self) -> SoEngineOutputData"""
        return _coin.SoDecomposeRotation_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoDecomposeRotation_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoDecomposeRotation 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(SoComposeMatrix self) -> SoType"""
        return _coin.SoComposeMatrix_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoComposeMatrix self) -> SoEngineOutputData"""
        return _coin.SoComposeMatrix_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoComposeMatrix_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoComposeMatrix 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__(SoMFMatrix 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(SoMFMatrix self) -> SoType"""
        return _coin.SoMFMatrix_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFMatrix self, SoField field)"""
        return _coin.SoMFMatrix_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFMatrix self, SoField field) -> SbBool"""
        return _coin.SoMFMatrix_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFMatrix self, SbMatrix value, SbBool addifnotfound=0) -> int
        find(SoMFMatrix self, SbMatrix value) -> int
        """
        return _coin.SoMFMatrix_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFMatrix self, int const idx, SbMatrix value)"""
        return _coin.SoMFMatrix_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFMatrix self, SoMFMatrix field) -> SbBool"""
        return _coin.SoMFMatrix___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFMatrix self, SoMFMatrix field) -> SbBool"""
        return _coin.SoMFMatrix___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFMatrix self) -> SbMatrix"""
        return _coin.SoMFMatrix_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFMatrix self)"""
        return _coin.SoMFMatrix_finishEditing(self)


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

    initClass = staticmethod(initClass)

    def __getitem__(self, i):
        """__getitem__(SoMFMatrix self, int i) -> SbMatrix"""
        return _coin.SoMFMatrix___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFMatrix self, int i, SbMatrix value)"""
        return _coin.SoMFMatrix___setitem__(self, i, value)


    def getValues(self, i=0):
        """
        getValues(SoMFMatrix self, int i=0) -> SbMatrix
        getValues(SoMFMatrix self) -> SbMatrix
        """
        return _coin.SoMFMatrix_getValues(self, i)


    def setValue(self, *args):
        """
        setValue(SoMFMatrix self, SbMatrix value)
        setValue(SoMFMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44)
        setValue(SoMFMatrix 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(SoDecomposeMatrix self) -> SoType"""
        return _coin.SoDecomposeMatrix_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoDecomposeMatrix self) -> SoEngineOutputData"""
        return _coin.SoDecomposeMatrix_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoDecomposeMatrix_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoDecomposeMatrix 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(SoComposeRotationFromTo self) -> SoType"""
        return _coin.SoComposeRotationFromTo_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoComposeRotationFromTo self) -> SoEngineOutputData"""
        return _coin.SoComposeRotationFromTo_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoComposeRotationFromTo_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoComposeRotationFromTo 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__(SoSFPath 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(SoSFPath self) -> SoType"""
        return _coin.SoSFPath_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFPath self, SoField field)"""
        return _coin.SoSFPath_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFPath self, SoField field) -> SbBool"""
        return _coin.SoSFPath_isSame(self, field)


    def getValue(self):
        """getValue(SoSFPath self) -> SoPath"""
        return _coin.SoSFPath_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFPath self, SoSFPath field) -> int"""
        return _coin.SoSFPath___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFPath self, SoSFPath field) -> int"""
        return _coin.SoSFPath___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def notify(self, l):
        """notify(SoSFPath self, SoNotList l)"""
        return _coin.SoSFPath_notify(self, l)


    def fixCopy(self, copyconnections):
        """fixCopy(SoSFPath self, SbBool copyconnections)"""
        return _coin.SoSFPath_fixCopy(self, copyconnections)


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


    def setValue(self, *args):
        """
        setValue(SoSFPath self, SoPath newvalue)
        setValue(SoSFPath 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(SoComputeBoundingBox self) -> SoType"""
        return _coin.SoComputeBoundingBox_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoComputeBoundingBox 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__(SoComputeBoundingBox 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, vpr):
        """setViewportRegion(SoComputeBoundingBox self, SbViewportRegion vpr)"""
        return _coin.SoComputeBoundingBox_setViewportRegion(self, vpr)


    def getViewportRegion(self):
        """getViewportRegion(SoComputeBoundingBox 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(SoConcatenate self) -> SoType"""
        return _coin.SoConcatenate_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoConcatenate 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, inputType):
        """__init__(SoConcatenate self, SoType inputType) -> SoConcatenate"""
        this = _coin.new_SoConcatenate(inputType)
        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__(SoSFTrigger 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(SoSFTrigger self) -> SoType"""
        return _coin.SoSFTrigger_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFTrigger self, SoField field)"""
        return _coin.SoSFTrigger_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFTrigger self, SoField field) -> SbBool"""
        return _coin.SoSFTrigger_isSame(self, field)


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

    initClass = staticmethod(initClass)

    def getValue(self):
        """getValue(SoSFTrigger self)"""
        return _coin.SoSFTrigger_getValue(self)


    def __eq__(self, trigger):
        """__eq__(SoSFTrigger self, SoSFTrigger trigger) -> int"""
        return _coin.SoSFTrigger___eq__(self, trigger)


    def __ne__(self, trigger):
        """__ne__(SoSFTrigger self, SoSFTrigger trigger) -> int"""
        return _coin.SoSFTrigger___ne__(self, trigger)


    def startNotify(self):
        """startNotify(SoSFTrigger self)"""
        return _coin.SoSFTrigger_startNotify(self)


    def notify(self, l):
        """notify(SoSFTrigger self, SoNotList l)"""
        return _coin.SoSFTrigger_notify(self, l)


    def touch(self):
        """touch(SoSFTrigger self)"""
        return _coin.SoSFTrigger_touch(self)


    def setValue(self, *args):
        """
        setValue(SoSFTrigger self)
        setValue(SoSFTrigger 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__(SoSFShort 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(SoSFShort self) -> SoType"""
        return _coin.SoSFShort_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFShort self, SoField field)"""
        return _coin.SoSFShort_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFShort self, SoField field) -> SbBool"""
        return _coin.SoSFShort_isSame(self, field)


    def getValue(self):
        """getValue(SoSFShort self) -> short"""
        return _coin.SoSFShort_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFShort self, SoSFShort field) -> int"""
        return _coin.SoSFShort___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFShort self, SoSFShort field) -> int"""
        return _coin.SoSFShort___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFShort self, short newvalue)
        setValue(SoSFShort 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(SoCounter self) -> SoType"""
        return _coin.SoCounter_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoCounter 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__(SoCounter 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__(SoSFTime 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(SoSFTime self) -> SoType"""
        return _coin.SoSFTime_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFTime self, SoField field)"""
        return _coin.SoSFTime_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFTime self, SoField field) -> SbBool"""
        return _coin.SoSFTime_isSame(self, field)


    def getValue(self):
        """getValue(SoSFTime self) -> SbTime"""
        return _coin.SoSFTime_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFTime self, SoSFTime field) -> int"""
        return _coin.SoSFTime___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFTime self, SoSFTime field) -> int"""
        return _coin.SoSFTime___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFTime self, SbTime newvalue)
        setValue(SoSFTime self, SbTime other)
        setValue(SoSFTime 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(SoElapsedTime self) -> SoType"""
        return _coin.SoElapsedTime_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoElapsedTime 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__(SoElapsedTime 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(SoFieldConverter self) -> SoType"""
        return _coin.SoFieldConverter_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoFieldConverter 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, type):
        """getInput(SoFieldConverter self, SoType type) -> SoField"""
        return _coin.SoFieldConverter_getInput(self, type)


    def getOutput(self, type):
        """getOutput(SoFieldConverter self, SoType type) -> SoEngineOutput"""
        return _coin.SoFieldConverter_getOutput(self, type)


    def getConnectedInput(self):
        """getConnectedInput(SoFieldConverter self) -> SoField"""
        return _coin.SoFieldConverter_getConnectedInput(self)


    def getForwardConnections(self, l):
        """getForwardConnections(SoFieldConverter self, SoFieldList l) -> int"""
        return _coin.SoFieldConverter_getForwardConnections(self, l)

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(SoGate self) -> SoType"""
        return _coin.SoGate_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoGate 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, type):
        """__init__(SoGate self, SoType type) -> SoGate"""
        this = _coin.new_SoGate(type)
        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(SoInterpolate self) -> SoType"""
        return _coin.SoInterpolate_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoInterpolate 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(SoInterpolateFloat self) -> SoType"""
        return _coin.SoInterpolateFloat_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoInterpolateFloat self) -> SoEngineOutputData"""
        return _coin.SoInterpolateFloat_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoInterpolateFloat_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoInterpolateFloat 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(SoInterpolateVec2f self) -> SoType"""
        return _coin.SoInterpolateVec2f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoInterpolateVec2f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec2f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoInterpolateVec2f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoInterpolateVec2f 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(SoInterpolateVec3f self) -> SoType"""
        return _coin.SoInterpolateVec3f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoInterpolateVec3f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec3f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoInterpolateVec3f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoInterpolateVec3f 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(SoInterpolateVec4f self) -> SoType"""
        return _coin.SoInterpolateVec4f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoInterpolateVec4f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec4f_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoInterpolateVec4f_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoInterpolateVec4f 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(SoInterpolateRotation self) -> SoType"""
        return _coin.SoInterpolateRotation_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoInterpolateRotation self) -> SoEngineOutputData"""
        return _coin.SoInterpolateRotation_getOutputData(self)


    def createInstance():
        """createInstance() -> void *"""
        return _coin.SoInterpolateRotation_createInstance()

    createInstance = staticmethod(createInstance)

    def __init__(self):
        """__init__(SoInterpolateRotation 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(SoOnOff self) -> SoType"""
        return _coin.SoOnOff_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoOnOff 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__(SoOnOff 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__(SoSFBitMask 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(SoSFBitMask self) -> SoType"""
        return _coin.SoSFBitMask_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBitMask self, SoField field)"""
        return _coin.SoSFBitMask_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBitMask self, SoField field) -> SbBool"""
        return _coin.SoSFBitMask_isSame(self, field)


    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(SoOneShot self) -> SoType"""
        return _coin.SoOneShot_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoOneShot 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__(SoOneShot 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(SoSelectOne self) -> SoType"""
        return _coin.SoSelectOne_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoSelectOne 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, inputtype):
        """__init__(SoSelectOne self, SoType inputtype) -> SoSelectOne"""
        this = _coin.new_SoSelectOne(inputtype)
        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(SoTimeCounter self) -> SoType"""
        return _coin.SoTimeCounter_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoTimeCounter 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__(SoTimeCounter 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(SoTransformVec3f self) -> SoType"""
        return _coin.SoTransformVec3f_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoTransformVec3f 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__(SoTransformVec3f 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(SoTriggerAny self) -> SoType"""
        return _coin.SoTriggerAny_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoTriggerAny 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__(SoTriggerAny 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(SoTexture2Convert self) -> SoType"""
        return _coin.SoTexture2Convert_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoTexture2Convert 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(SoHeightMapToNormalMap self) -> SoType"""
        return _coin.SoHeightMapToNormalMap_getTypeId(self)


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


    def getOutputData(self):
        """getOutputData(SoHeightMapToNormalMap 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__(SoHeightMapToNormalMap 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(srcptr, size, nc, dst_out):
        """convert(unsigned char const * srcptr, SbVec2s size, int nc, SbImage dst_out)"""
        return _coin.SoHeightMapToNormalMap_convert(srcptr, size, nc, dst_out)

    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(srcptr, size, nc, dst_out):
    """SoHeightMapToNormalMap_convert(unsigned char const * srcptr, SbVec2s size, int nc, SbImage dst_out)"""
    return _coin.SoHeightMapToNormalMap_convert(srcptr, size, nc, dst_out)

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(SoNodeEngine self)"""
        return _coin.SoNodeEngine_evaluateWrapper(self)


    def getOutputs(self, l):
        """getOutputs(SoNodeEngine self, SoEngineOutputList l) -> int"""
        return _coin.SoNodeEngine_getOutputs(self, l)


    def getOutput(self, outputname):
        """getOutput(SoNodeEngine self, SbName outputname) -> SoEngineOutput"""
        return _coin.SoNodeEngine_getOutput(self, outputname)


    def getOutputName(self, output, outputname):
        """getOutputName(SoNodeEngine self, SoEngineOutput output, SbName outputname) -> SbBool"""
        return _coin.SoNodeEngine_getOutputName(self, output, outputname)


    def getOutputData(self):
        """getOutputData(SoNodeEngine self) -> SoEngineOutputData"""
        return _coin.SoNodeEngine_getOutputData(self)


    def isNotifying(self):
        """isNotifying(SoNodeEngine self) -> SbBool"""
        return _coin.SoNodeEngine_isNotifying(self)


    def notify(self, nl):
        """notify(SoNodeEngine self, SoNotList nl)"""
        return _coin.SoNodeEngine_notify(self, nl)


    def writeInstance(self, out):
        """writeInstance(SoNodeEngine self, SoOutput out)"""
        return _coin.SoNodeEngine_writeInstance(self, out)

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(callback, data):
        """setHandlerCallback(SoErrorCB *const callback, void *const data)"""
        return _coin.SoMemoryError_setHandlerCallback(callback, data)

    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(SoMemoryError self) -> SoType"""
        return _coin.SoMemoryError_getTypeId(self)


    def post(whatWasAllocated):
        """post(char const *const whatWasAllocated)"""
        return _coin.SoMemoryError_post(whatWasAllocated)

    post = staticmethod(post)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoMemoryError 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(callback, data):
    """SoMemoryError_setHandlerCallback(SoErrorCB *const callback, void *const data)"""
    return _coin.SoMemoryError_setHandlerCallback(callback, data)

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(whatWasAllocated):
    """SoMemoryError_post(char const *const whatWasAllocated)"""
    return _coin.SoMemoryError_post(whatWasAllocated)

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(function, data):
        """setHandlerCallback(SoErrorCB *const function, void *const data)"""
        return _coin.SoReadError_setHandlerCallback(function, data)

    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(SoReadError self) -> SoType"""
        return _coin.SoReadError_getTypeId(self)


    def post(input, format):
        """post(SoInput input, char const *const format)"""
        return _coin.SoReadError_post(input, format)

    post = staticmethod(post)

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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoReadError 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(function, data):
    """SoReadError_setHandlerCallback(SoErrorCB *const function, void *const data)"""
    return _coin.SoReadError_setHandlerCallback(function, data)

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(input, format):
    """SoReadError_post(SoInput input, char const *const format)"""
    return _coin.SoReadError_post(input, format)

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(SoButtonEvent self) -> SoType"""
        return _coin.SoButtonEvent_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoButtonEvent 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, state):
        """setState(SoButtonEvent self, SoButtonEvent::State state)"""
        return _coin.SoButtonEvent_setState(self, state)


    def getState(self):
        """getState(SoButtonEvent self) -> SoButtonEvent::State"""
        return _coin.SoButtonEvent_getState(self)


    def enumToString(enumval, stringrep):
        """enumToString(SoButtonEvent::State enumval, SbString stringrep) -> SbBool"""
        return _coin.SoButtonEvent_enumToString(enumval, stringrep)

    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(enumval, stringrep):
    """SoButtonEvent_enumToString(SoButtonEvent::State enumval, SbString stringrep) -> SbBool"""
    return _coin.SoButtonEvent_enumToString(enumval, stringrep)

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(SoLocation2Event self) -> SoType"""
        return _coin.SoLocation2Event_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoLocation2Event 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(SoMotion3Event self) -> SoType"""
        return _coin.SoMotion3Event_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoMotion3Event 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, t):
        """setTranslation(SoMotion3Event self, SbVec3f t)"""
        return _coin.SoMotion3Event_setTranslation(self, t)


    def getTranslation(self):
        """getTranslation(SoMotion3Event self) -> SbVec3f"""
        return _coin.SoMotion3Event_getTranslation(self)


    def setRotation(self, r):
        """setRotation(SoMotion3Event self, SbRotation r)"""
        return _coin.SoMotion3Event_setRotation(self, r)


    def getRotation(self):
        """getRotation(SoMotion3Event 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(SoKeyboardEvent self) -> SoType"""
        return _coin.SoKeyboardEvent_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoKeyboardEvent 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, key):
        """setKey(SoKeyboardEvent self, SoKeyboardEvent::Key key)"""
        return _coin.SoKeyboardEvent_setKey(self, key)


    def getKey(self):
        """getKey(SoKeyboardEvent self) -> SoKeyboardEvent::Key"""
        return _coin.SoKeyboardEvent_getKey(self)


    def setPrintableCharacter(self, c):
        """setPrintableCharacter(SoKeyboardEvent self, char const c)"""
        return _coin.SoKeyboardEvent_setPrintableCharacter(self, c)


    def getPrintableCharacter(self):
        """getPrintableCharacter(SoKeyboardEvent self) -> char"""
        return _coin.SoKeyboardEvent_getPrintableCharacter(self)


    def isKeyPressEvent(e, whichKey):
        """isKeyPressEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
        return _coin.SoKeyboardEvent_isKeyPressEvent(e, whichKey)

    isKeyPressEvent = staticmethod(isKeyPressEvent)

    def isKeyReleaseEvent(e, whichKey):
        """isKeyReleaseEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
        return _coin.SoKeyboardEvent_isKeyReleaseEvent(e, whichKey)

    isKeyReleaseEvent = staticmethod(isKeyReleaseEvent)

    def enumToString(enumval, stringrep):
        """enumToString(SoKeyboardEvent::Key enumval, SbString stringrep) -> SbBool"""
        return _coin.SoKeyboardEvent_enumToString(enumval, stringrep)

    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(e, whichKey):
    """SoKeyboardEvent_isKeyPressEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
    return _coin.SoKeyboardEvent_isKeyPressEvent(e, whichKey)

def SoKeyboardEvent_isKeyReleaseEvent(e, whichKey):
    """SoKeyboardEvent_isKeyReleaseEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
    return _coin.SoKeyboardEvent_isKeyReleaseEvent(e, whichKey)

def SoKeyboardEvent_enumToString(enumval, stringrep):
    """SoKeyboardEvent_enumToString(SoKeyboardEvent::Key enumval, SbString stringrep) -> SbBool"""
    return _coin.SoKeyboardEvent_enumToString(enumval, stringrep)

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(SoMouseButtonEvent self) -> SoType"""
        return _coin.SoMouseButtonEvent_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoMouseButtonEvent 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, button):
        """setButton(SoMouseButtonEvent self, SoMouseButtonEvent::Button button)"""
        return _coin.SoMouseButtonEvent_setButton(self, button)


    def getButton(self):
        """getButton(SoMouseButtonEvent self) -> SoMouseButtonEvent::Button"""
        return _coin.SoMouseButtonEvent_getButton(self)


    def isButtonPressEvent(e, whichButton):
        """isButtonPressEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoMouseButtonEvent_isButtonPressEvent(e, whichButton)

    isButtonPressEvent = staticmethod(isButtonPressEvent)

    def isButtonReleaseEvent(e, whichButton):
        """isButtonReleaseEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoMouseButtonEvent_isButtonReleaseEvent(e, whichButton)

    isButtonReleaseEvent = staticmethod(isButtonReleaseEvent)

    def enumToString(enumval, stringrep):
        """enumToString(SoMouseButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
        return _coin.SoMouseButtonEvent_enumToString(enumval, stringrep)

    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(e, whichButton):
    """SoMouseButtonEvent_isButtonPressEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
    return _coin.SoMouseButtonEvent_isButtonPressEvent(e, whichButton)

def SoMouseButtonEvent_isButtonReleaseEvent(e, whichButton):
    """SoMouseButtonEvent_isButtonReleaseEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
    return _coin.SoMouseButtonEvent_isButtonReleaseEvent(e, whichButton)

def SoMouseButtonEvent_enumToString(enumval, stringrep):
    """SoMouseButtonEvent_enumToString(SoMouseButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
    return _coin.SoMouseButtonEvent_enumToString(enumval, stringrep)

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(SoSpaceballButtonEvent self) -> SoType"""
        return _coin.SoSpaceballButtonEvent_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSpaceballButtonEvent 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, button):
        """setButton(SoSpaceballButtonEvent self, SoSpaceballButtonEvent::Button button)"""
        return _coin.SoSpaceballButtonEvent_setButton(self, button)


    def getButton(self):
        """getButton(SoSpaceballButtonEvent self) -> SoSpaceballButtonEvent::Button"""
        return _coin.SoSpaceballButtonEvent_getButton(self)


    def isButtonPressEvent(e, whichButton):
        """isButtonPressEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_isButtonPressEvent(e, whichButton)

    isButtonPressEvent = staticmethod(isButtonPressEvent)

    def isButtonReleaseEvent(e, whichButton):
        """isButtonReleaseEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_isButtonReleaseEvent(e, whichButton)

    isButtonReleaseEvent = staticmethod(isButtonReleaseEvent)

    def enumToString(enumval, stringrep):
        """enumToString(SoSpaceballButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_enumToString(enumval, stringrep)

    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(e, whichButton):
    """SoSpaceballButtonEvent_isButtonPressEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
    return _coin.SoSpaceballButtonEvent_isButtonPressEvent(e, whichButton)

def SoSpaceballButtonEvent_isButtonReleaseEvent(e, whichButton):
    """SoSpaceballButtonEvent_isButtonReleaseEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
    return _coin.SoSpaceballButtonEvent_isButtonReleaseEvent(e, whichButton)

def SoSpaceballButtonEvent_enumToString(enumval, stringrep):
    """SoSpaceballButtonEvent_enumToString(SoSpaceballButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
    return _coin.SoSpaceballButtonEvent_enumToString(enumval, stringrep)

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__(SbBox2s self) -> SbBox2s
        __init__(SbBox2s self, short xmin, short ymin, short xmax, short ymax) -> SbBox2s
        __init__(SbBox2s self, SbVec2s minpoint, SbVec2s maxpoint) -> SbBox2s
        __init__(SbBox2s self, SbBox2i32 box) -> SbBox2s
        __init__(SbBox2s self, SbBox2f box) -> SbBox2s
        __init__(SbBox2s self, SbBox2d box) -> SbBox2s
        """
        this = _coin.new_SbBox2s(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setBounds(self, *args):
        """
        setBounds(SbBox2s self, short xmin, short ymin, short xmax, short ymax) -> SbBox2s
        setBounds(SbBox2s self, SbVec2s minpoint, SbVec2s maxpoint) -> SbBox2s
        setBounds(SbBox2s self, SbBox2i32 box) -> SbBox2s
        setBounds(SbBox2s self, SbBox2f box) -> SbBox2s
        setBounds(SbBox2s self, SbBox2d box) -> SbBox2s
        """
        return _coin.SbBox2s_setBounds(self, *args)


    def getBounds(self, *args):
        """
        getBounds(SbBox2s self, short & xmin, short & ymin, short & xmax, short & ymax)
        getBounds(SbBox2s self, SbVec2s minpoint, SbVec2s maxpoint)
        """
        return _coin.SbBox2s_getBounds(self, *args)


    def getMin(self, *args):
        """
        getMin(SbBox2s self) -> SbVec2s
        getMin(SbBox2s self) -> SbVec2s
        """
        return _coin.SbBox2s_getMin(self, *args)


    def getMax(self, *args):
        """
        getMax(SbBox2s self) -> SbVec2s
        getMax(SbBox2s self) -> SbVec2s
        """
        return _coin.SbBox2s_getMax(self, *args)


    def extendBy(self, *args):
        """
        extendBy(SbBox2s self, SbVec2s point)
        extendBy(SbBox2s self, SbBox2s box)
        """
        return _coin.SbBox2s_extendBy(self, *args)


    def makeEmpty(self):
        """makeEmpty(SbBox2s self)"""
        return _coin.SbBox2s_makeEmpty(self)


    def isEmpty(self):
        """isEmpty(SbBox2s self) -> SbBool"""
        return _coin.SbBox2s_isEmpty(self)


    def hasArea(self):
        """hasArea(SbBox2s self) -> SbBool"""
        return _coin.SbBox2s_hasArea(self)


    def intersect(self, *args):
        """
        intersect(SbBox2s self, SbVec2s point) -> SbBool
        intersect(SbBox2s self, SbBox2s box) -> SbBool
        """
        return _coin.SbBox2s_intersect(self, *args)


    def getCenter(self):
        """getCenter(SbBox2s self) -> SbVec2f"""
        return _coin.SbBox2s_getCenter(self)


    def getOrigin(self, originX, originY):
        """getOrigin(SbBox2s self, short & originX, short & originY)"""
        return _coin.SbBox2s_getOrigin(self, originX, originY)


    def getSize(self, sizeX, sizeY):
        """getSize(SbBox2s self, short & sizeX, short & sizeY)"""
        return _coin.SbBox2s_getSize(self, sizeX, sizeY)


    def getAspectRatio(self):
        """getAspectRatio(SbBox2s self) -> float"""
        return _coin.SbBox2s_getAspectRatio(self)


    def __eq__(self, u):
        """__eq__(SbBox2s self, SbBox2s u) -> int"""
        return _coin.SbBox2s___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbBox2s self, SbBox2s u) -> int"""
        return _coin.SbBox2s___ne__(self, u)

    __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__(SoSFBox2s 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(SoSFBox2s self) -> SoType"""
        return _coin.SoSFBox2s_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBox2s self, SoField field)"""
        return _coin.SoSFBox2s_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBox2s self, SoField field) -> SbBool"""
        return _coin.SoSFBox2s_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFBox2s self, SoSFBox2s field) -> int"""
        return _coin.SoSFBox2s___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBox2s self, SoSFBox2s field) -> int"""
        return _coin.SoSFBox2s___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBox2s self, SbBox2s newvalue)
        setValue(SoSFBox2s self, short xmin, short ymin, short xmax, short ymax)
        setValue(SoSFBox2s self, SbVec2s minvec, SbVec2s maxvec)
        """
        return _coin.SoSFBox2s_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SoSFBox2s self) -> SbBox2s
        getValue(SoSFBox2s 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__(SbVec2i32 self) -> SbVec2i32
        __init__(SbVec2i32 self, int32_t const [2] v) -> SbVec2i32
        __init__(SbVec2i32 self, int32_t x, int32_t y) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2ui32 const & v) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2b v) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2s v) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2f v) -> SbVec2i32
        __init__(SbVec2i32 self, SbVec2d v) -> SbVec2i32
        """
        this = _coin.new_SbVec2i32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec2i32 self, int32_t const [2] v) -> SbVec2i32
        setValue(SbVec2i32 self, int32_t x, int32_t y) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2ui32 const & v) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2b v) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2s v) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2f v) -> SbVec2i32
        setValue(SbVec2i32 self, SbVec2d v) -> SbVec2i32
        """
        return _coin.SbVec2i32_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec2i32 self) -> int32_t const
        getValue(SbVec2i32 self, int32_t & x, int32_t & y)
        """
        return _coin.SbVec2i32_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec2i32 self, SbVec2i32 v) -> int32_t"""
        return _coin.SbVec2i32_dot(self, v)


    def negate(self):
        """negate(SbVec2i32 self)"""
        return _coin.SbVec2i32_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec2i32 self, SbVec2i32 v) -> SbVec2i32"""
        return _coin.SbVec2i32___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec2i32 self, SbVec2i32 v) -> SbVec2i32"""
        return _coin.SbVec2i32___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec2i32 self) -> SbVec2i32"""
        return _coin.SbVec2i32___neg__(self)


    def output(self, fp):
        """output(SbVec2i32 self, FILE * fp)"""
        return _coin.SbVec2i32_output(self, fp)

    __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__(SbBox2i32 self) -> SbBox2i32
        __init__(SbBox2i32 self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax) -> SbBox2i32
        __init__(SbBox2i32 self, SbVec2i32 minpoint, SbVec2i32 maxpoint) -> SbBox2i32
        __init__(SbBox2i32 self, SbBox2s box) -> SbBox2i32
        __init__(SbBox2i32 self, SbBox2f box) -> SbBox2i32
        __init__(SbBox2i32 self, SbBox2d box) -> SbBox2i32
        """
        this = _coin.new_SbBox2i32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setBounds(self, *args):
        """
        setBounds(SbBox2i32 self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax) -> SbBox2i32
        setBounds(SbBox2i32 self, SbVec2i32 minpoint, SbVec2i32 maxpoint) -> SbBox2i32
        setBounds(SbBox2i32 self, SbBox2s box) -> SbBox2i32
        setBounds(SbBox2i32 self, SbBox2f box) -> SbBox2i32
        setBounds(SbBox2i32 self, SbBox2d box) -> SbBox2i32
        """
        return _coin.SbBox2i32_setBounds(self, *args)


    def getBounds(self, *args):
        """
        getBounds(SbBox2i32 self, int32_t & xmin, int32_t & ymin, int32_t & xmax, int32_t & ymax)
        getBounds(SbBox2i32 self, SbVec2i32 minpoint, SbVec2i32 maxpoint)
        """
        return _coin.SbBox2i32_getBounds(self, *args)


    def getMin(self, *args):
        """
        getMin(SbBox2i32 self) -> SbVec2i32
        getMin(SbBox2i32 self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getMin(self, *args)


    def getMax(self, *args):
        """
        getMax(SbBox2i32 self) -> SbVec2i32
        getMax(SbBox2i32 self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getMax(self, *args)


    def extendBy(self, *args):
        """
        extendBy(SbBox2i32 self, SbVec2i32 point)
        extendBy(SbBox2i32 self, SbBox2i32 box)
        """
        return _coin.SbBox2i32_extendBy(self, *args)


    def makeEmpty(self):
        """makeEmpty(SbBox2i32 self)"""
        return _coin.SbBox2i32_makeEmpty(self)


    def isEmpty(self):
        """isEmpty(SbBox2i32 self) -> SbBool"""
        return _coin.SbBox2i32_isEmpty(self)


    def hasArea(self):
        """hasArea(SbBox2i32 self) -> SbBool"""
        return _coin.SbBox2i32_hasArea(self)


    def intersect(self, *args):
        """
        intersect(SbBox2i32 self, SbVec2i32 point) -> SbBool
        intersect(SbBox2i32 self, SbBox2i32 box) -> SbBool
        """
        return _coin.SbBox2i32_intersect(self, *args)


    def getCenter(self):
        """getCenter(SbBox2i32 self) -> SbVec2f"""
        return _coin.SbBox2i32_getCenter(self)


    def getOrigin(self, originX, originY):
        """getOrigin(SbBox2i32 self, int32_t & originX, int32_t & originY)"""
        return _coin.SbBox2i32_getOrigin(self, originX, originY)


    def getSize(self, sizeX, sizeY):
        """getSize(SbBox2i32 self, int32_t & sizeX, int32_t & sizeY)"""
        return _coin.SbBox2i32_getSize(self, sizeX, sizeY)


    def getAspectRatio(self):
        """getAspectRatio(SbBox2i32 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__(SoSFBox2i32 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(SoSFBox2i32 self) -> SoType"""
        return _coin.SoSFBox2i32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBox2i32 self, SoField field)"""
        return _coin.SoSFBox2i32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBox2i32 self, SoField field) -> SbBool"""
        return _coin.SoSFBox2i32_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFBox2i32 self, SoSFBox2i32 field) -> int"""
        return _coin.SoSFBox2i32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBox2i32 self, SoSFBox2i32 field) -> int"""
        return _coin.SoSFBox2i32___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBox2i32 self, SbBox2i32 newvalue)
        setValue(SoSFBox2i32 self, int32_t xmin, int32_t ymin, int32_t xmax, int32_t ymax)
        setValue(SoSFBox2i32 self, SbVec2i32 minvec, SbVec2i32 maxvec)
        """
        return _coin.SoSFBox2i32_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SoSFBox2i32 self) -> SbBox2i32
        getValue(SoSFBox2i32 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__(SbBox2f self) -> SbBox2f
        __init__(SbBox2f self, float xmin, float ymin, float xmax, float ymax) -> SbBox2f
        __init__(SbBox2f self, SbVec2f minpoint, SbVec2f maxpoint) -> SbBox2f
        __init__(SbBox2f self, SbBox2d box) -> SbBox2f
        __init__(SbBox2f self, SbBox2s box) -> SbBox2f
        __init__(SbBox2f self, SbBox2i32 box) -> SbBox2f
        """
        this = _coin.new_SbBox2f(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setBounds(self, *args):
        """
        setBounds(SbBox2f self, float xmin, float ymin, float xmax, float ymax) -> SbBox2f
        setBounds(SbBox2f self, SbVec2f minpoint, SbVec2f maxpoint) -> SbBox2f
        setBounds(SbBox2f self, SbBox2d box) -> SbBox2f
        setBounds(SbBox2f self, SbBox2s box) -> SbBox2f
        setBounds(SbBox2f self, SbBox2i32 box) -> SbBox2f
        """
        return _coin.SbBox2f_setBounds(self, *args)


    def getBounds(self, *args):
        """
        getBounds(SbBox2f self, float & xmin, float & ymin, float & xmax, float & ymax)
        getBounds(SbBox2f self, SbVec2f minpoint, SbVec2f maxpoint)
        """
        return _coin.SbBox2f_getBounds(self, *args)


    def getMin(self, *args):
        """
        getMin(SbBox2f self) -> SbVec2f
        getMin(SbBox2f self) -> SbVec2f
        """
        return _coin.SbBox2f_getMin(self, *args)


    def getMax(self, *args):
        """
        getMax(SbBox2f self) -> SbVec2f
        getMax(SbBox2f self) -> SbVec2f
        """
        return _coin.SbBox2f_getMax(self, *args)


    def extendBy(self, *args):
        """
        extendBy(SbBox2f self, SbVec2f point)
        extendBy(SbBox2f self, SbBox2f box)
        """
        return _coin.SbBox2f_extendBy(self, *args)


    def makeEmpty(self):
        """makeEmpty(SbBox2f self)"""
        return _coin.SbBox2f_makeEmpty(self)


    def isEmpty(self):
        """isEmpty(SbBox2f self) -> SbBool"""
        return _coin.SbBox2f_isEmpty(self)


    def hasArea(self):
        """hasArea(SbBox2f self) -> SbBool"""
        return _coin.SbBox2f_hasArea(self)


    def intersect(self, *args):
        """
        intersect(SbBox2f self, SbVec2f point) -> SbBool
        intersect(SbBox2f self, SbBox2f box) -> SbBool
        """
        return _coin.SbBox2f_intersect(self, *args)


    def getClosestPoint(self, point):
        """getClosestPoint(SbBox2f self, SbVec2f point) -> SbVec2f"""
        return _coin.SbBox2f_getClosestPoint(self, point)


    def getCenter(self):
        """getCenter(SbBox2f self) -> SbVec2f"""
        return _coin.SbBox2f_getCenter(self)


    def getOrigin(self, originX, originY):
        """getOrigin(SbBox2f self, float & originX, float & originY)"""
        return _coin.SbBox2f_getOrigin(self, originX, originY)


    def getSize(self, sizeX, sizeY):
        """getSize(SbBox2f self, float & sizeX, float & sizeY)"""
        return _coin.SbBox2f_getSize(self, sizeX, sizeY)


    def getAspectRatio(self):
        """getAspectRatio(SbBox2f self) -> float"""
        return _coin.SbBox2f_getAspectRatio(self)


    def __eq__(self, u):
        """__eq__(SbBox2f self, SbBox2f u) -> int"""
        return _coin.SbBox2f___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbBox2f self, SbBox2f u) -> int"""
        return _coin.SbBox2f___ne__(self, u)

    __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__(SoSFBox2f 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(SoSFBox2f self) -> SoType"""
        return _coin.SoSFBox2f_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBox2f self, SoField field)"""
        return _coin.SoSFBox2f_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBox2f self, SoField field) -> SbBool"""
        return _coin.SoSFBox2f_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFBox2f self, SoSFBox2f field) -> int"""
        return _coin.SoSFBox2f___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBox2f self, SoSFBox2f field) -> int"""
        return _coin.SoSFBox2f___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBox2f self, SbBox2f newvalue)
        setValue(SoSFBox2f self, float xmin, float ymin, float xmax, float ymax)
        setValue(SoSFBox2f self, SbVec2f minvec, SbVec2f maxvec)
        """
        return _coin.SoSFBox2f_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SoSFBox2f self) -> SbBox2f
        getValue(SoSFBox2f 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__(SbVec2d self) -> SbVec2d
        __init__(SbVec2d self, double const [2] v) -> SbVec2d
        __init__(SbVec2d self, double x, double y) -> SbVec2d
        __init__(SbVec2d self, SbVec2f v) -> SbVec2d
        __init__(SbVec2d self, SbVec2b v) -> SbVec2d
        __init__(SbVec2d self, SbVec2s v) -> SbVec2d
        __init__(SbVec2d self, SbVec2i32 v) -> SbVec2d
        """
        this = _coin.new_SbVec2d(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec2d self, double const [2] v) -> SbVec2d
        setValue(SbVec2d self, double x, double y) -> SbVec2d
        setValue(SbVec2d self, SbVec2f v) -> SbVec2d
        setValue(SbVec2d self, SbVec2b v) -> SbVec2d
        setValue(SbVec2d self, SbVec2s v) -> SbVec2d
        setValue(SbVec2d self, SbVec2i32 v) -> SbVec2d
        """
        return _coin.SbVec2d_setValue(self, *args)


    def getValue(self):
        """getValue(SbVec2d self)"""
        return _coin.SbVec2d_getValue(self)


    def equals(self, v, tolerance):
        """equals(SbVec2d self, SbVec2d v, double tolerance) -> SbBool"""
        return _coin.SbVec2d_equals(self, v, tolerance)


    def dot(self, v):
        """dot(SbVec2d self, SbVec2d v) -> double"""
        return _coin.SbVec2d_dot(self, v)


    def length(self):
        """length(SbVec2d self) -> double"""
        return _coin.SbVec2d_length(self)


    def sqrLength(self):
        """sqrLength(SbVec2d self) -> double"""
        return _coin.SbVec2d_sqrLength(self)


    def normalize(self):
        """normalize(SbVec2d self) -> double"""
        return _coin.SbVec2d_normalize(self)


    def negate(self):
        """negate(SbVec2d self)"""
        return _coin.SbVec2d_negate(self)


    def __imul__(self, d):
        """__imul__(SbVec2d self, double d) -> SbVec2d"""
        return _coin.SbVec2d___imul__(self, d)


    def __idiv__(self, d):
        """__idiv__(SbVec2d self, double d) -> SbVec2d"""
        return _coin.SbVec2d___idiv__(self, d)


    def __iadd__(self, v):
        """__iadd__(SbVec2d self, SbVec2d v) -> SbVec2d"""
        return _coin.SbVec2d___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec2d self, SbVec2d v) -> SbVec2d"""
        return _coin.SbVec2d___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec2d self) -> SbVec2d"""
        return _coin.SbVec2d___neg__(self)


    def output(self, fp):
        """output(SbVec2d self, FILE * fp)"""
        return _coin.SbVec2d_output(self, fp)


    def __add__(self, u):
        """__add__(SbVec2d self, SbVec2d u) -> SbVec2d"""
        return _coin.SbVec2d___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbVec2d self, SbVec2d u) -> SbVec2d"""
        return _coin.SbVec2d___sub__(self, u)


    def __mul__(self, d):
        """__mul__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___mul__(self, d)


    def __rmul__(self, d):
        """__rmul__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbVec2d self, SbVec2d u) -> int"""
        return _coin.SbVec2d___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbVec2d self, SbVec2d u) -> int"""
        return _coin.SbVec2d___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbVec2d self, int i) -> double"""
        return _coin.SbVec2d___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SbVec2d self, int i, double value)"""
        return _coin.SbVec2d___setitem__(self, i, value)


    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__(SbBox2d self) -> SbBox2d
        __init__(SbBox2d self, double xmin, double ymin, double xmax, double ymax) -> SbBox2d
        __init__(SbBox2d self, SbVec2d minpoint, SbVec2d maxpoint) -> SbBox2d
        __init__(SbBox2d self, SbBox2f box) -> SbBox2d
        __init__(SbBox2d self, SbBox2s box) -> SbBox2d
        __init__(SbBox2d self, SbBox2i32 box) -> SbBox2d
        """
        this = _coin.new_SbBox2d(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setBounds(self, *args):
        """
        setBounds(SbBox2d self, double xmin, double ymin, double xmax, double ymax) -> SbBox2d
        setBounds(SbBox2d self, SbVec2d minpoint, SbVec2d maxpoint) -> SbBox2d
        setBounds(SbBox2d self, SbBox2f box) -> SbBox2d
        setBounds(SbBox2d self, SbBox2s box) -> SbBox2d
        setBounds(SbBox2d self, SbBox2i32 box) -> SbBox2d
        """
        return _coin.SbBox2d_setBounds(self, *args)


    def getBounds(self, *args):
        """
        getBounds(SbBox2d self, double & xmin, double & ymin, double & xmax, double & ymax)
        getBounds(SbBox2d self, SbVec2d minpoint, SbVec2d maxpoint)
        """
        return _coin.SbBox2d_getBounds(self, *args)


    def getMin(self, *args):
        """
        getMin(SbBox2d self) -> SbVec2d
        getMin(SbBox2d self) -> SbVec2d
        """
        return _coin.SbBox2d_getMin(self, *args)


    def getMax(self, *args):
        """
        getMax(SbBox2d self) -> SbVec2d
        getMax(SbBox2d self) -> SbVec2d
        """
        return _coin.SbBox2d_getMax(self, *args)


    def extendBy(self, *args):
        """
        extendBy(SbBox2d self, SbVec2d point)
        extendBy(SbBox2d self, SbBox2d box)
        """
        return _coin.SbBox2d_extendBy(self, *args)


    def makeEmpty(self):
        """makeEmpty(SbBox2d self)"""
        return _coin.SbBox2d_makeEmpty(self)


    def isEmpty(self):
        """isEmpty(SbBox2d self) -> SbBool"""
        return _coin.SbBox2d_isEmpty(self)


    def hasArea(self):
        """hasArea(SbBox2d self) -> SbBool"""
        return _coin.SbBox2d_hasArea(self)


    def intersect(self, *args):
        """
        intersect(SbBox2d self, SbVec2d point) -> SbBool
        intersect(SbBox2d self, SbBox2d box) -> SbBool
        """
        return _coin.SbBox2d_intersect(self, *args)


    def getClosestPoint(self, p):
        """getClosestPoint(SbBox2d self, SbVec2d p) -> SbVec2d"""
        return _coin.SbBox2d_getClosestPoint(self, p)


    def findIntersection(self, a, b, ia, ib):
        """findIntersection(SbBox2d self, SbVec2d a, SbVec2d b, SbVec2d ia, SbVec2d ib) -> SbBool"""
        return _coin.SbBox2d_findIntersection(self, a, b, ia, ib)


    def getCenter(self):
        """getCenter(SbBox2d self) -> SbVec2d"""
        return _coin.SbBox2d_getCenter(self)


    def getOrigin(self, originX, originY):
        """getOrigin(SbBox2d self, double & originX, double & originY)"""
        return _coin.SbBox2d_getOrigin(self, originX, originY)


    def getSize(self, sizeX, sizeY):
        """getSize(SbBox2d self, double & sizeX, double & sizeY)"""
        return _coin.SbBox2d_getSize(self, sizeX, sizeY)


    def getAspectRatio(self):
        """getAspectRatio(SbBox2d self) -> double"""
        return _coin.SbBox2d_getAspectRatio(self)


    def __eq__(self, u):
        """__eq__(SbBox2d self, SbBox2d u) -> int"""
        return _coin.SbBox2d___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbBox2d self, SbBox2d u) -> int"""
        return _coin.SbBox2d___ne__(self, u)


    def setValue(self, u):
        """setValue(SbBox2d self, SbBox2d u) -> SbBox2d"""
        return _coin.SbBox2d_setValue(self, u)

    __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__(SoSFBox2d 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(SoSFBox2d self) -> SoType"""
        return _coin.SoSFBox2d_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBox2d self, SoField field)"""
        return _coin.SoSFBox2d_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBox2d self, SoField field) -> SbBool"""
        return _coin.SoSFBox2d_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFBox2d self, SoSFBox2d field) -> int"""
        return _coin.SoSFBox2d___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBox2d self, SoSFBox2d field) -> int"""
        return _coin.SoSFBox2d___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBox2d self, SbBox2d newvalue)
        setValue(SoSFBox2d self, double xmin, double ymin, double xmax, double ymax)
        setValue(SoSFBox2d self, SbVec2d minvec, SbVec2d maxvec)
        """
        return _coin.SoSFBox2d_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SoSFBox2d self) -> SbBox2d
        getValue(SoSFBox2d 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__(SbBox3s self) -> SbBox3s
        __init__(SbBox3s self, short xmin, short ymin, short zmin, short xmax, short ymax, short zmax) -> SbBox3s
        __init__(SbBox3s self, SbVec3s minpoint, SbVec3s maxpoint) -> SbBox3s
        __init__(SbBox3s self, SbBox3i32 box) -> SbBox3s
        __init__(SbBox3s self, SbBox3f box) -> SbBox3s
        __init__(SbBox3s self, SbBox3d box) -> SbBox3s
        """
        this = _coin.new_SbBox3s(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setBounds(self, *args):
        """
        setBounds(SbBox3s self, short xmin, short ymin, short zmin, short xmax, short ymax, short zmax) -> SbBox3s
        setBounds(SbBox3s self, SbVec3s minpoint, SbVec3s maxpoint) -> SbBox3s
        setBounds(SbBox3s self, SbBox3i32 box) -> SbBox3s
        setBounds(SbBox3s self, SbBox3f box) -> SbBox3s
        setBounds(SbBox3s self, SbBox3d box) -> SbBox3s
        """
        return _coin.SbBox3s_setBounds(self, *args)


    def getBounds(self, *args):
        """
        getBounds(SbBox3s self, short & xmin, short & ymin, short & zmin, short & xmax, short & ymax, short & zmax)
        getBounds(SbBox3s self, SbVec3s minpoint, SbVec3s maxpoint)
        """
        return _coin.SbBox3s_getBounds(self, *args)


    def getMin(self, *args):
        """
        getMin(SbBox3s self) -> SbVec3s
        getMin(SbBox3s self) -> SbVec3s
        """
        return _coin.SbBox3s_getMin(self, *args)


    def getMax(self, *args):
        """
        getMax(SbBox3s self) -> SbVec3s
        getMax(SbBox3s self) -> SbVec3s
        """
        return _coin.SbBox3s_getMax(self, *args)


    def extendBy(self, *args):
        """
        extendBy(SbBox3s self, SbVec3s pt)
        extendBy(SbBox3s self, SbBox3s box)
        """
        return _coin.SbBox3s_extendBy(self, *args)


    def makeEmpty(self):
        """makeEmpty(SbBox3s self)"""
        return _coin.SbBox3s_makeEmpty(self)


    def isEmpty(self):
        """isEmpty(SbBox3s self) -> SbBool"""
        return _coin.SbBox3s_isEmpty(self)


    def hasVolume(self):
        """hasVolume(SbBox3s self) -> SbBool"""
        return _coin.SbBox3s_hasVolume(self)


    def getVolume(self):
        """getVolume(SbBox3s self) -> int"""
        return _coin.SbBox3s_getVolume(self)


    def intersect(self, *args):
        """
        intersect(SbBox3s self, SbVec3s pt) -> SbBool
        intersect(SbBox3s self, SbBox3s box) -> SbBool
        """
        return _coin.SbBox3s_intersect(self, *args)


    def getClosestPoint(self, pt):
        """getClosestPoint(SbBox3s self, SbVec3f pt) -> SbVec3f"""
        return _coin.SbBox3s_getClosestPoint(self, pt)


    def getCenter(self):
        """getCenter(SbBox3s self) -> SbVec3f"""
        return _coin.SbBox3s_getCenter(self)


    def getOrigin(self, originX, originY, originZ):
        """getOrigin(SbBox3s self, short & originX, short & originY, short & originZ)"""
        return _coin.SbBox3s_getOrigin(self, originX, originY, originZ)


    def getSize(self, sizeX, sizeY, sizeZ):
        """getSize(SbBox3s self, short & sizeX, short & sizeY, short & sizeZ)"""
        return _coin.SbBox3s_getSize(self, sizeX, sizeY, sizeZ)


    def __eq__(self, u):
        """__eq__(SbBox3s self, SbBox3s u) -> int"""
        return _coin.SbBox3s___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbBox3s self, SbBox3s u) -> int"""
        return _coin.SbBox3s___ne__(self, u)

    __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__(SoSFBox3s 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(SoSFBox3s self) -> SoType"""
        return _coin.SoSFBox3s_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBox3s self, SoField field)"""
        return _coin.SoSFBox3s_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBox3s self, SoField field) -> SbBool"""
        return _coin.SoSFBox3s_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFBox3s self, SoSFBox3s field) -> int"""
        return _coin.SoSFBox3s___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBox3s self, SoSFBox3s field) -> int"""
        return _coin.SoSFBox3s___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBox3s self, SbBox3s newvalue)
        setValue(SoSFBox3s self, short xmin, short ymin, short zmin, short xmax, short ymax, short zmax)
        setValue(SoSFBox3s self, SbVec3s minvec, SbVec3s maxvec)
        """
        return _coin.SoSFBox3s_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SoSFBox3s self) -> SbBox3s
        getValue(SoSFBox3s 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__(SbVec3i32 self) -> SbVec3i32
        __init__(SbVec3i32 self, int32_t const [3] v) -> SbVec3i32
        __init__(SbVec3i32 self, int32_t x, int32_t y, int32_t z) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3ui32 const & v) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3b v) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3s v) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3f v) -> SbVec3i32
        __init__(SbVec3i32 self, SbVec3d v) -> SbVec3i32
        """
        this = _coin.new_SbVec3i32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec3i32 self, int32_t const [3] v) -> SbVec3i32
        setValue(SbVec3i32 self, int32_t x, int32_t y, int32_t z) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3ui32 const & v) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3b v) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3s v) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3f v) -> SbVec3i32
        setValue(SbVec3i32 self, SbVec3d v) -> SbVec3i32
        """
        return _coin.SbVec3i32_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec3i32 self) -> int32_t const
        getValue(SbVec3i32 self, int32_t & x, int32_t & y, int32_t & z)
        """
        return _coin.SbVec3i32_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec3i32 self, SbVec3i32 v) -> int32_t"""
        return _coin.SbVec3i32_dot(self, v)


    def negate(self):
        """negate(SbVec3i32 self)"""
        return _coin.SbVec3i32_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec3i32 self, SbVec3i32 v) -> SbVec3i32"""
        return _coin.SbVec3i32___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec3i32 self, SbVec3i32 v) -> SbVec3i32"""
        return _coin.SbVec3i32___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec3i32 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__(SbBox3i32 self) -> SbBox3i32
        __init__(SbBox3i32 self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax) -> SbBox3i32
        __init__(SbBox3i32 self, SbVec3i32 minpoint, SbVec3i32 maxpoint) -> SbBox3i32
        __init__(SbBox3i32 self, SbBox3s box) -> SbBox3i32
        __init__(SbBox3i32 self, SbBox3f box) -> SbBox3i32
        __init__(SbBox3i32 self, SbBox3d box) -> SbBox3i32
        """
        this = _coin.new_SbBox3i32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setBounds(self, *args):
        """
        setBounds(SbBox3i32 self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax) -> SbBox3i32
        setBounds(SbBox3i32 self, SbVec3i32 minpoint, SbVec3i32 maxpoint) -> SbBox3i32
        setBounds(SbBox3i32 self, SbBox3s box) -> SbBox3i32
        setBounds(SbBox3i32 self, SbBox3f box) -> SbBox3i32
        setBounds(SbBox3i32 self, SbBox3d box) -> SbBox3i32
        """
        return _coin.SbBox3i32_setBounds(self, *args)


    def getBounds(self, *args):
        """
        getBounds(SbBox3i32 self, int32_t & xmin, int32_t & ymin, int32_t & zmin, int32_t & xmax, int32_t & ymax, int32_t & zmax)
        getBounds(SbBox3i32 self, SbVec3i32 minpoint, SbVec3i32 maxpoint)
        """
        return _coin.SbBox3i32_getBounds(self, *args)


    def getMin(self, *args):
        """
        getMin(SbBox3i32 self) -> SbVec3i32
        getMin(SbBox3i32 self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getMin(self, *args)


    def getMax(self, *args):
        """
        getMax(SbBox3i32 self) -> SbVec3i32
        getMax(SbBox3i32 self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getMax(self, *args)


    def extendBy(self, *args):
        """
        extendBy(SbBox3i32 self, SbVec3i32 pt)
        extendBy(SbBox3i32 self, SbBox3i32 bb)
        extendBy(SbBox3i32 self, SbVec3f pt)
        """
        return _coin.SbBox3i32_extendBy(self, *args)


    def transform(self, m):
        """transform(SbBox3i32 self, SbMatrix m)"""
        return _coin.SbBox3i32_transform(self, m)


    def makeEmpty(self):
        """makeEmpty(SbBox3i32 self)"""
        return _coin.SbBox3i32_makeEmpty(self)


    def isEmpty(self):
        """isEmpty(SbBox3i32 self) -> SbBool"""
        return _coin.SbBox3i32_isEmpty(self)


    def hasVolume(self):
        """hasVolume(SbBox3i32 self) -> SbBool"""
        return _coin.SbBox3i32_hasVolume(self)


    def getVolume(self):
        """getVolume(SbBox3i32 self) -> float"""
        return _coin.SbBox3i32_getVolume(self)


    def intersect(self, *args):
        """
        intersect(SbBox3i32 self, SbVec3i32 pt) -> SbBool
        intersect(SbBox3i32 self, SbBox3i32 bb) -> SbBool
        intersect(SbBox3i32 self, SbVec3f pt) -> SbBool
        """
        return _coin.SbBox3i32_intersect(self, *args)


    def outside(self, MVP, cullBits):
        """outside(SbBox3i32 self, SbMatrix MVP, int & cullBits) -> SbBool"""
        return _coin.SbBox3i32_outside(self, MVP, cullBits)


    def getClosestPoint(self, pt):
        """getClosestPoint(SbBox3i32 self, SbVec3f pt) -> SbVec3f"""
        return _coin.SbBox3i32_getClosestPoint(self, pt)


    def getCenter(self):
        """getCenter(SbBox3i32 self) -> SbVec3f"""
        return _coin.SbBox3i32_getCenter(self)


    def getOrigin(self, originX, originY, originZ):
        """getOrigin(SbBox3i32 self, int32_t & originX, int32_t & originY, int32_t & originZ)"""
        return _coin.SbBox3i32_getOrigin(self, originX, originY, originZ)


    def getSize(self, sizeX, sizeY, sizeZ):
        """getSize(SbBox3i32 self, int32_t & sizeX, int32_t & sizeY, int32_t sizeZ)"""
        return _coin.SbBox3i32_getSize(self, sizeX, sizeY, sizeZ)


    def getSpan(self, direction, dmin, dmax):
        """getSpan(SbBox3i32 self, SbVec3f direction, float & dmin, float & dmax)"""
        return _coin.SbBox3i32_getSpan(self, direction, dmin, dmax)

    __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__(SoSFBox3i32 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(SoSFBox3i32 self) -> SoType"""
        return _coin.SoSFBox3i32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBox3i32 self, SoField field)"""
        return _coin.SoSFBox3i32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBox3i32 self, SoField field) -> SbBool"""
        return _coin.SoSFBox3i32_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFBox3i32 self, SoSFBox3i32 field) -> int"""
        return _coin.SoSFBox3i32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBox3i32 self, SoSFBox3i32 field) -> int"""
        return _coin.SoSFBox3i32___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBox3i32 self, SbBox3i32 newvalue)
        setValue(SoSFBox3i32 self, int32_t xmin, int32_t ymin, int32_t zmin, int32_t xmax, int32_t ymax, int32_t zmax)
        setValue(SoSFBox3i32 self, SbVec3i32 minvec, SbVec3i32 maxvec)
        """
        return _coin.SoSFBox3i32_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SoSFBox3i32 self) -> SbBox3i32
        getValue(SoSFBox3i32 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__(SoSFBox3f 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(SoSFBox3f self) -> SoType"""
        return _coin.SoSFBox3f_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBox3f self, SoField field)"""
        return _coin.SoSFBox3f_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBox3f self, SoField field) -> SbBool"""
        return _coin.SoSFBox3f_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFBox3f self, SoSFBox3f field) -> int"""
        return _coin.SoSFBox3f___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBox3f self, SoSFBox3f field) -> int"""
        return _coin.SoSFBox3f___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBox3f self, SbBox3f newvalue)
        setValue(SoSFBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax)
        setValue(SoSFBox3f self, SbVec3f minvec, SbVec3f maxvec)
        """
        return _coin.SoSFBox3f_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SoSFBox3f self) -> SbBox3f
        getValue(SoSFBox3f 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__(SbBox3d self) -> SbBox3d
        __init__(SbBox3d self, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax) -> SbBox3d
        __init__(SbBox3d self, SbVec3d minpoint, SbVec3d maxpoint) -> SbBox3d
        __init__(SbBox3d self, SbBox3f box) -> SbBox3d
        __init__(SbBox3d self, SbBox3s box) -> SbBox3d
        __init__(SbBox3d self, SbBox3i32 box) -> SbBox3d
        """
        this = _coin.new_SbBox3d(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setBounds(self, *args):
        """
        setBounds(SbBox3d self, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax) -> SbBox3d
        setBounds(SbBox3d self, SbVec3d minpoint, SbVec3d maxpoint) -> SbBox3d
        setBounds(SbBox3d self, SbBox3f box) -> SbBox3d
        setBounds(SbBox3d self, SbBox3s box) -> SbBox3d
        setBounds(SbBox3d self, SbBox3i32 box) -> SbBox3d
        """
        return _coin.SbBox3d_setBounds(self, *args)


    def getBounds(self, *args):
        """
        getBounds(SbBox3d self, double & xmin, double & ymin, double & zmin, double & xmax, double & ymax, double & zmax)
        getBounds(SbBox3d self, SbVec3d minpoint, SbVec3d maxpoint)
        """
        return _coin.SbBox3d_getBounds(self, *args)


    def getMin(self, *args):
        """
        getMin(SbBox3d self) -> SbVec3d
        getMin(SbBox3d self) -> SbVec3d
        """
        return _coin.SbBox3d_getMin(self, *args)


    def getMax(self, *args):
        """
        getMax(SbBox3d self) -> SbVec3d
        getMax(SbBox3d self) -> SbVec3d
        """
        return _coin.SbBox3d_getMax(self, *args)


    def extendBy(self, *args):
        """
        extendBy(SbBox3d self, SbVec3d pt)
        extendBy(SbBox3d self, SbBox3d box)
        """
        return _coin.SbBox3d_extendBy(self, *args)


    def transform(self, matrix):
        """transform(SbBox3d self, SbDPMatrix matrix)"""
        return _coin.SbBox3d_transform(self, matrix)


    def makeEmpty(self):
        """makeEmpty(SbBox3d self)"""
        return _coin.SbBox3d_makeEmpty(self)


    def isEmpty(self):
        """isEmpty(SbBox3d self) -> SbBool"""
        return _coin.SbBox3d_isEmpty(self)


    def hasVolume(self):
        """hasVolume(SbBox3d self) -> SbBool"""
        return _coin.SbBox3d_hasVolume(self)


    def getVolume(self):
        """getVolume(SbBox3d self) -> double"""
        return _coin.SbBox3d_getVolume(self)


    def intersect(self, *args):
        """
        intersect(SbBox3d self, SbVec3d point) -> SbBool
        intersect(SbBox3d self, SbBox3d box) -> SbBool
        """
        return _coin.SbBox3d_intersect(self, *args)


    def getClosestPoint(self, point):
        """getClosestPoint(SbBox3d self, SbVec3d point) -> SbVec3d"""
        return _coin.SbBox3d_getClosestPoint(self, point)


    def outside(self, mvp, cullbits):
        """outside(SbBox3d self, SbDPMatrix mvp, int & cullbits) -> SbBool"""
        return _coin.SbBox3d_outside(self, mvp, cullbits)


    def getCenter(self):
        """getCenter(SbBox3d self) -> SbVec3d"""
        return _coin.SbBox3d_getCenter(self)


    def getOrigin(self, origoX, origoY, origoZ):
        """getOrigin(SbBox3d self, double & origoX, double & origoY, double & origoZ)"""
        return _coin.SbBox3d_getOrigin(self, origoX, origoY, origoZ)


    def getSize(self, *args):
        """
        getSize(SbBox3d self, double & sizeX, double & sizeY, double & sizeZ)
        getSize(SbBox3d self) -> SbVec3d
        """
        return _coin.SbBox3d_getSize(self, *args)


    def getSpan(self, dir, dmin, dmax):
        """getSpan(SbBox3d self, SbVec3d dir, double & dmin, double & dmax)"""
        return _coin.SbBox3d_getSpan(self, dir, dmin, dmax)


    def output(self, file):
        """output(SbBox3d self, FILE * file)"""
        return _coin.SbBox3d_output(self, file)

    __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__(SoSFBox3d 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(SoSFBox3d self) -> SoType"""
        return _coin.SoSFBox3d_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFBox3d self, SoField field)"""
        return _coin.SoSFBox3d_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFBox3d self, SoField field) -> SbBool"""
        return _coin.SoSFBox3d_isSame(self, field)


    def __eq__(self, field):
        """__eq__(SoSFBox3d self, SoSFBox3d field) -> int"""
        return _coin.SoSFBox3d___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFBox3d self, SoSFBox3d field) -> int"""
        return _coin.SoSFBox3d___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFBox3d self, SbBox3d newvalue)
        setValue(SoSFBox3d self, double xmin, double ymin, double zmin, double xmax, double ymax, double zmax)
        setValue(SoSFBox3d self, SbVec3d minvec, SbVec3d maxvec)
        """
        return _coin.SoSFBox3d_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SoSFBox3d self) -> SbBox3d
        getValue(SoSFBox3d 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__(SoSFColorRGBA 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(SoSFColorRGBA self) -> SoType"""
        return _coin.SoSFColorRGBA_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFColorRGBA self, SoField field)"""
        return _coin.SoSFColorRGBA_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFColorRGBA self, SoField field) -> SbBool"""
        return _coin.SoSFColorRGBA_isSame(self, field)


    def getValue(self):
        """getValue(SoSFColorRGBA self) -> SbColor4f"""
        return _coin.SoSFColorRGBA_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFColorRGBA self, SoSFColorRGBA field) -> int"""
        return _coin.SoSFColorRGBA___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFColorRGBA self, SoSFColorRGBA field) -> int"""
        return _coin.SoSFColorRGBA___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFColorRGBA self, SbColor4f newvalue)
        setValue(SoSFColorRGBA self, SbVec4f vec)
        setValue(SoSFColorRGBA self, float red, float green, float blue, float alpha)
        setValue(SoSFColorRGBA self, float const [4] rgba)
        """
        return _coin.SoSFColorRGBA_setValue(self, *args)


    def setHSVValue(self, *args):
        """
        setHSVValue(SoSFColorRGBA self, float h, float s, float v, float a)
        setHSVValue(SoSFColorRGBA self, float const [4] 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__(SoSFDouble 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(SoSFDouble self) -> SoType"""
        return _coin.SoSFDouble_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFDouble self, SoField field)"""
        return _coin.SoSFDouble_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFDouble self, SoField field) -> SbBool"""
        return _coin.SoSFDouble_isSame(self, field)


    def getValue(self):
        """getValue(SoSFDouble self) -> double"""
        return _coin.SoSFDouble_getValue(self)


    def setValue(self, newvalue):
        """setValue(SoSFDouble self, double newvalue)"""
        return _coin.SoSFDouble_setValue(self, newvalue)


    def __eq__(self, field):
        """__eq__(SoSFDouble self, SoSFDouble field) -> int"""
        return _coin.SoSFDouble___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFDouble self, SoSFDouble field) -> int"""
        return _coin.SoSFDouble___ne__(self, field)


    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__(SoSFEngine 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(SoSFEngine self) -> SoType"""
        return _coin.SoSFEngine_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFEngine self, SoField field)"""
        return _coin.SoSFEngine_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFEngine self, SoField field) -> SbBool"""
        return _coin.SoSFEngine_isSame(self, field)


    def getValue(self):
        """getValue(SoSFEngine self) -> SoEngine"""
        return _coin.SoSFEngine_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFEngine self, SoSFEngine field) -> int"""
        return _coin.SoSFEngine___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFEngine self, SoSFEngine field) -> int"""
        return _coin.SoSFEngine___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def fixCopy(self, copyconnections):
        """fixCopy(SoSFEngine self, SbBool copyconnections)"""
        return _coin.SoSFEngine_fixCopy(self, copyconnections)


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


    def setValue(self, *args):
        """
        setValue(SoSFEngine self, SoEngine newvalue)
        setValue(SoSFEngine 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__(SoSFImage3 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(SoSFImage3 self) -> SoType"""
        return _coin.SoSFImage3_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFImage3 self, SoField field)"""
        return _coin.SoSFImage3_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFImage3 self, SoField field) -> SbBool"""
        return _coin.SoSFImage3_isSame(self, field)


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

    initClass = staticmethod(initClass)

    def getValue(self):
        """getValue(SoSFImage3 self) -> unsigned char const *"""
        return _coin.SoSFImage3_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFImage3 self, SoSFImage3 field) -> int"""
        return _coin.SoSFImage3___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFImage3 self, SoSFImage3 field) -> int"""
        return _coin.SoSFImage3___ne__(self, field)


    def startEditing(self):
        """startEditing(SoSFImage3 self) -> unsigned char *"""
        return _coin.SoSFImage3_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoSFImage3 self)"""
        return _coin.SoSFImage3_finishEditing(self)


    def setValue(self, *args):
        """
        setValue(SoSFImage3 self, SbVec3s size, int const nc, unsigned char const * bytes)
        setValue(SoSFImage3 self, SbVec3s size, int const nc, PyObject * pixels)
        setValue(SoSFImage3 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__(SoSFMatrix 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(SoSFMatrix self) -> SoType"""
        return _coin.SoSFMatrix_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFMatrix self, SoField field)"""
        return _coin.SoSFMatrix_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFMatrix self, SoField field) -> SbBool"""
        return _coin.SoSFMatrix_isSame(self, field)


    def getValue(self):
        """getValue(SoSFMatrix self) -> SbMatrix"""
        return _coin.SoSFMatrix_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFMatrix self, SoSFMatrix field) -> int"""
        return _coin.SoSFMatrix___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFMatrix self, SoSFMatrix field) -> int"""
        return _coin.SoSFMatrix___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFMatrix self, SbMatrix newvalue)
        setValue(SoSFMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44)
        setValue(SoSFMatrix 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__(SoSFPlane 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(SoSFPlane self) -> SoType"""
        return _coin.SoSFPlane_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFPlane self, SoField field)"""
        return _coin.SoSFPlane_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFPlane self, SoField field) -> SbBool"""
        return _coin.SoSFPlane_isSame(self, field)


    def getValue(self):
        """getValue(SoSFPlane self) -> SbPlane"""
        return _coin.SoSFPlane_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFPlane self, SoSFPlane field) -> int"""
        return _coin.SoSFPlane___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFPlane self, SoSFPlane field) -> int"""
        return _coin.SoSFPlane___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFPlane self, SbPlane newvalue)
        setValue(SoSFPlane 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__(SoSFUInt32 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(SoSFUInt32 self) -> SoType"""
        return _coin.SoSFUInt32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFUInt32 self, SoField field)"""
        return _coin.SoSFUInt32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFUInt32 self, SoField field) -> SbBool"""
        return _coin.SoSFUInt32_isSame(self, field)


    def getValue(self):
        """getValue(SoSFUInt32 self) -> uint32_t"""
        return _coin.SoSFUInt32_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFUInt32 self, SoSFUInt32 field) -> int"""
        return _coin.SoSFUInt32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFUInt32 self, SoSFUInt32 field) -> int"""
        return _coin.SoSFUInt32___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFUInt32 self, uint32_t newvalue)
        setValue(SoSFUInt32 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__(SbVec2b self) -> SbVec2b
        __init__(SbVec2b self, int8_t const [2] v) -> SbVec2b
        __init__(SbVec2b self, int8_t x, int8_t y) -> SbVec2b
        __init__(SbVec2b self, SbVec2ub const & v) -> SbVec2b
        __init__(SbVec2b self, SbVec2s v) -> SbVec2b
        __init__(SbVec2b self, SbVec2i32 v) -> SbVec2b
        __init__(SbVec2b self, SbVec2f v) -> SbVec2b
        __init__(SbVec2b self, SbVec2d v) -> SbVec2b
        """
        this = _coin.new_SbVec2b(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec2b self, int8_t const [2] v) -> SbVec2b
        setValue(SbVec2b self, int8_t x, int8_t y) -> SbVec2b
        setValue(SbVec2b self, SbVec2ub const & v) -> SbVec2b
        setValue(SbVec2b self, SbVec2s v) -> SbVec2b
        setValue(SbVec2b self, SbVec2i32 v) -> SbVec2b
        setValue(SbVec2b self, SbVec2f v) -> SbVec2b
        setValue(SbVec2b self, SbVec2d v) -> SbVec2b
        """
        return _coin.SbVec2b_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec2b self) -> int8_t const
        getValue(SbVec2b self, int8_t & x, int8_t & y)
        """
        return _coin.SbVec2b_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec2b self, SbVec2b v) -> int32_t"""
        return _coin.SbVec2b_dot(self, v)


    def negate(self):
        """negate(SbVec2b self)"""
        return _coin.SbVec2b_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec2b self, SbVec2b v) -> SbVec2b"""
        return _coin.SbVec2b___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec2b self, SbVec2b v) -> SbVec2b"""
        return _coin.SbVec2b___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec2b 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__(SoSFVec2b 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(SoSFVec2b self) -> SoType"""
        return _coin.SoSFVec2b_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec2b self, SoField field)"""
        return _coin.SoSFVec2b_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec2b self, SoField field) -> SbBool"""
        return _coin.SoSFVec2b_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec2b self) -> SbVec2b"""
        return _coin.SoSFVec2b_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec2b self, SoSFVec2b field) -> int"""
        return _coin.SoSFVec2b___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec2b self, SoSFVec2b field) -> int"""
        return _coin.SoSFVec2b___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec2b self, SbVec2b newvalue)
        setValue(SoSFVec2b self, int8_t x, int8_t y)
        setValue(SoSFVec2b self, int8_t const [2] 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__(SoSFVec2s 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(SoSFVec2s self) -> SoType"""
        return _coin.SoSFVec2s_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec2s self, SoField field)"""
        return _coin.SoSFVec2s_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec2s self, SoField field) -> SbBool"""
        return _coin.SoSFVec2s_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec2s self) -> SbVec2s"""
        return _coin.SoSFVec2s_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec2s self, SoSFVec2s field) -> int"""
        return _coin.SoSFVec2s___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec2s self, SoSFVec2s field) -> int"""
        return _coin.SoSFVec2s___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec2s self, SbVec2s newvalue)
        setValue(SoSFVec2s self, short x, short y)
        setValue(SoSFVec2s self, short const [2] 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__(SoSFVec2i32 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(SoSFVec2i32 self) -> SoType"""
        return _coin.SoSFVec2i32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec2i32 self, SoField field)"""
        return _coin.SoSFVec2i32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec2i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec2i32_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec2i32 self) -> SbVec2i32"""
        return _coin.SoSFVec2i32_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec2i32 self, SoSFVec2i32 field) -> int"""
        return _coin.SoSFVec2i32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec2i32 self, SoSFVec2i32 field) -> int"""
        return _coin.SoSFVec2i32___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec2i32 self, SbVec2i32 newvalue)
        setValue(SoSFVec2i32 self, int32_t x, int32_t y)
        setValue(SoSFVec2i32 self, int32_t const [2] 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__(SoSFVec2d 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(SoSFVec2d self) -> SoType"""
        return _coin.SoSFVec2d_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec2d self, SoField field)"""
        return _coin.SoSFVec2d_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec2d self, SoField field) -> SbBool"""
        return _coin.SoSFVec2d_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec2d self) -> SbVec2d"""
        return _coin.SoSFVec2d_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec2d self, SoSFVec2d field) -> int"""
        return _coin.SoSFVec2d___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec2d self, SoSFVec2d field) -> int"""
        return _coin.SoSFVec2d___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec2d self, SbVec2d newvalue)
        setValue(SoSFVec2d self, double x, double y)
        setValue(SoSFVec2d self, double const [2] 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__(SbVec3b self) -> SbVec3b
        __init__(SbVec3b self, int8_t const [3] v) -> SbVec3b
        __init__(SbVec3b self, int8_t x, int8_t y, int8_t z) -> SbVec3b
        __init__(SbVec3b self, SbVec3ub const & v) -> SbVec3b
        __init__(SbVec3b self, SbVec3s v) -> SbVec3b
        __init__(SbVec3b self, SbVec3i32 v) -> SbVec3b
        __init__(SbVec3b self, SbVec3f v) -> SbVec3b
        __init__(SbVec3b self, SbVec3d v) -> SbVec3b
        """
        this = _coin.new_SbVec3b(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec3b self, int8_t [3] v) -> SbVec3b
        setValue(SbVec3b self, int8_t x, int8_t y, int8_t z) -> SbVec3b
        setValue(SbVec3b self, SbVec3ub const & v) -> SbVec3b
        setValue(SbVec3b self, SbVec3s v) -> SbVec3b
        setValue(SbVec3b self, SbVec3i32 v) -> SbVec3b
        setValue(SbVec3b self, SbVec3f v) -> SbVec3b
        setValue(SbVec3b self, SbVec3d v) -> SbVec3b
        """
        return _coin.SbVec3b_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec3b self) -> int8_t const
        getValue(SbVec3b self, int8_t & x, int8_t & y, int8_t & z)
        """
        return _coin.SbVec3b_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec3b self, SbVec3b v) -> int32_t"""
        return _coin.SbVec3b_dot(self, v)


    def negate(self):
        """negate(SbVec3b self)"""
        return _coin.SbVec3b_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec3b self, SbVec3b v) -> SbVec3b"""
        return _coin.SbVec3b___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec3b self, SbVec3b v) -> SbVec3b"""
        return _coin.SbVec3b___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec3b 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__(SoSFVec3b 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(SoSFVec3b self) -> SoType"""
        return _coin.SoSFVec3b_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec3b self, SoField field)"""
        return _coin.SoSFVec3b_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec3b self, SoField field) -> SbBool"""
        return _coin.SoSFVec3b_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec3b self) -> SbVec3b"""
        return _coin.SoSFVec3b_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec3b self, SoSFVec3b field) -> int"""
        return _coin.SoSFVec3b___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec3b self, SoSFVec3b field) -> int"""
        return _coin.SoSFVec3b___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec3b self, SbVec3b newvalue)
        setValue(SoSFVec3b self, int8_t x, int8_t y, int8_t z)
        setValue(SoSFVec3b self, int8_t const [3] 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__(SoSFVec3s 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(SoSFVec3s self) -> SoType"""
        return _coin.SoSFVec3s_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec3s self, SoField field)"""
        return _coin.SoSFVec3s_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec3s self, SoField field) -> SbBool"""
        return _coin.SoSFVec3s_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec3s self) -> SbVec3s"""
        return _coin.SoSFVec3s_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec3s self, SoSFVec3s field) -> int"""
        return _coin.SoSFVec3s___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec3s self, SoSFVec3s field) -> int"""
        return _coin.SoSFVec3s___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec3s self, SbVec3s newvalue)
        setValue(SoSFVec3s self, short x, short y, short z)
        setValue(SoSFVec3s self, short const [3] 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__(SoSFVec3i32 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(SoSFVec3i32 self) -> SoType"""
        return _coin.SoSFVec3i32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec3i32 self, SoField field)"""
        return _coin.SoSFVec3i32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec3i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec3i32_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec3i32 self) -> SbVec3i32"""
        return _coin.SoSFVec3i32_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec3i32 self, SoSFVec3i32 field) -> int"""
        return _coin.SoSFVec3i32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec3i32 self, SoSFVec3i32 field) -> int"""
        return _coin.SoSFVec3i32___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec3i32 self, SbVec3i32 newvalue)
        setValue(SoSFVec3i32 self, int32_t x, int32_t y, int32_t z)
        setValue(SoSFVec3i32 self, int32_t const [3] 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__(SoSFVec3d 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(SoSFVec3d self) -> SoType"""
        return _coin.SoSFVec3d_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec3d self, SoField field)"""
        return _coin.SoSFVec3d_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec3d self, SoField field) -> SbBool"""
        return _coin.SoSFVec3d_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec3d self) -> SbVec3d"""
        return _coin.SoSFVec3d_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec3d self, SoSFVec3d field) -> int"""
        return _coin.SoSFVec3d___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec3d self, SoSFVec3d field) -> int"""
        return _coin.SoSFVec3d___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec3d self, SbVec3d newvalue)
        setValue(SoSFVec3d self, double x, double y, double z)
        setValue(SoSFVec3d self, double const [3] 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__(SbVec4b self) -> SbVec4b
        __init__(SbVec4b self, int8_t const [4] v) -> SbVec4b
        __init__(SbVec4b self, int8_t x, int8_t y, int8_t z, int8_t w) -> SbVec4b
        __init__(SbVec4b self, SbVec4ub v) -> SbVec4b
        __init__(SbVec4b self, SbVec4s v) -> SbVec4b
        __init__(SbVec4b self, SbVec4i32 v) -> SbVec4b
        __init__(SbVec4b self, SbVec4f v) -> SbVec4b
        __init__(SbVec4b self, SbVec4d v) -> SbVec4b
        """
        this = _coin.new_SbVec4b(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec4b self, int8_t const [4] v) -> SbVec4b
        setValue(SbVec4b self, int8_t x, int8_t y, int8_t z, int8_t w) -> SbVec4b
        setValue(SbVec4b self, SbVec4ub v) -> SbVec4b
        setValue(SbVec4b self, SbVec4s v) -> SbVec4b
        setValue(SbVec4b self, SbVec4i32 v) -> SbVec4b
        setValue(SbVec4b self, SbVec4f v) -> SbVec4b
        setValue(SbVec4b self, SbVec4d v) -> SbVec4b
        """
        return _coin.SbVec4b_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec4b self) -> int8_t const
        getValue(SbVec4b self, int8_t & x, int8_t & y, int8_t & z, int8_t & w)
        """
        return _coin.SbVec4b_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec4b self, SbVec4b v) -> int32_t"""
        return _coin.SbVec4b_dot(self, v)


    def negate(self):
        """negate(SbVec4b self)"""
        return _coin.SbVec4b_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec4b self, SbVec4b v) -> SbVec4b"""
        return _coin.SbVec4b___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec4b self, SbVec4b v) -> SbVec4b"""
        return _coin.SbVec4b___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec4b 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__(SoSFVec4b 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(SoSFVec4b self) -> SoType"""
        return _coin.SoSFVec4b_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec4b self, SoField field)"""
        return _coin.SoSFVec4b_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec4b self, SoField field) -> SbBool"""
        return _coin.SoSFVec4b_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec4b self) -> SbVec4b"""
        return _coin.SoSFVec4b_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec4b self, SoSFVec4b field) -> int"""
        return _coin.SoSFVec4b___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec4b self, SoSFVec4b field) -> int"""
        return _coin.SoSFVec4b___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec4b self, SbVec4b newvalue)
        setValue(SoSFVec4b self, int8_t x, int8_t y, int8_t z, int8_t w)
        setValue(SoSFVec4b self, int8_t const [4] 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__(SbVec4ub self) -> SbVec4ub
        __init__(SbVec4ub self, uint8_t const [4] v) -> SbVec4ub
        __init__(SbVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w) -> SbVec4ub
        __init__(SbVec4ub self, SbVec4b v) -> SbVec4ub
        __init__(SbVec4ub self, SbVec4us v) -> SbVec4ub
        __init__(SbVec4ub self, SbVec4ui32 v) -> SbVec4ub
        """
        this = _coin.new_SbVec4ub(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec4ub self, uint8_t const [4] v) -> SbVec4ub
        setValue(SbVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w) -> SbVec4ub
        setValue(SbVec4ub self, SbVec4b v) -> SbVec4ub
        setValue(SbVec4ub self, SbVec4us v) -> SbVec4ub
        setValue(SbVec4ub self, SbVec4ui32 v) -> SbVec4ub
        """
        return _coin.SbVec4ub_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec4ub self) -> uint8_t const
        getValue(SbVec4ub self, uint8_t & x, uint8_t & y, uint8_t & z, uint8_t & w)
        """
        return _coin.SbVec4ub_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec4ub self, SbVec4ub v) -> int32_t"""
        return _coin.SbVec4ub_dot(self, v)


    def negate(self):
        """negate(SbVec4ub self)"""
        return _coin.SbVec4ub_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec4ub self, SbVec4ub v) -> SbVec4ub"""
        return _coin.SbVec4ub___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec4ub self, SbVec4ub v) -> SbVec4ub"""
        return _coin.SbVec4ub___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec4ub 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__(SoSFVec4ub 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(SoSFVec4ub self) -> SoType"""
        return _coin.SoSFVec4ub_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec4ub self, SoField field)"""
        return _coin.SoSFVec4ub_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec4ub self, SoField field) -> SbBool"""
        return _coin.SoSFVec4ub_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec4ub self) -> SbVec4ub"""
        return _coin.SoSFVec4ub_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec4ub self, SoSFVec4ub field) -> int"""
        return _coin.SoSFVec4ub___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec4ub self, SoSFVec4ub field) -> int"""
        return _coin.SoSFVec4ub___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec4ub self, SbVec4ub newvalue)
        setValue(SoSFVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        setValue(SoSFVec4ub self, uint8_t const [4] 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__(SbVec4s self) -> SbVec4s
        __init__(SbVec4s self, short const [4] v) -> SbVec4s
        __init__(SbVec4s self, short x, short y, short z, short w) -> SbVec4s
        __init__(SbVec4s self, SbVec4us v) -> SbVec4s
        __init__(SbVec4s self, SbVec4b v) -> SbVec4s
        __init__(SbVec4s self, SbVec4i32 v) -> SbVec4s
        __init__(SbVec4s self, SbVec4f v) -> SbVec4s
        __init__(SbVec4s self, SbVec4d v) -> SbVec4s
        """
        this = _coin.new_SbVec4s(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec4s self, short const [4] v) -> SbVec4s
        setValue(SbVec4s self, short x, short y, short z, short w) -> SbVec4s
        setValue(SbVec4s self, SbVec4s v) -> SbVec4s
        setValue(SbVec4s self, SbVec4us v) -> SbVec4s
        setValue(SbVec4s self, SbVec4b v) -> SbVec4s
        setValue(SbVec4s self, SbVec4i32 v) -> SbVec4s
        setValue(SbVec4s self, SbVec4f v) -> SbVec4s
        setValue(SbVec4s self, SbVec4d v) -> SbVec4s
        """
        return _coin.SbVec4s_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec4s self) -> short const
        getValue(SbVec4s self, short & w)
        """
        return _coin.SbVec4s_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec4s self, SbVec4s v) -> int32_t"""
        return _coin.SbVec4s_dot(self, v)


    def negate(self):
        """negate(SbVec4s self)"""
        return _coin.SbVec4s_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec4s self, SbVec4s v) -> SbVec4s"""
        return _coin.SbVec4s___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec4s self, SbVec4s v) -> SbVec4s"""
        return _coin.SbVec4s___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec4s 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__(SoSFVec4s 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(SoSFVec4s self) -> SoType"""
        return _coin.SoSFVec4s_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec4s self, SoField field)"""
        return _coin.SoSFVec4s_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec4s self, SoField field) -> SbBool"""
        return _coin.SoSFVec4s_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec4s self) -> SbVec4s"""
        return _coin.SoSFVec4s_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec4s self, SoSFVec4s field) -> int"""
        return _coin.SoSFVec4s___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec4s self, SoSFVec4s field) -> int"""
        return _coin.SoSFVec4s___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec4s self, SbVec4s newvalue)
        setValue(SoSFVec4s self, short x, short y, short z, short w)
        setValue(SoSFVec4s self, short const [4] 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__(SbVec4us self) -> SbVec4us
        __init__(SbVec4us self, unsigned short const [4] v) -> SbVec4us
        __init__(SbVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w) -> SbVec4us
        __init__(SbVec4us self, SbVec4s v) -> SbVec4us
        __init__(SbVec4us self, SbVec4ub v) -> SbVec4us
        __init__(SbVec4us self, SbVec4ui32 v) -> SbVec4us
        """
        this = _coin.new_SbVec4us(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec4us self, unsigned short const [4] v) -> SbVec4us
        setValue(SbVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w) -> SbVec4us
        setValue(SbVec4us self, SbVec4s v) -> SbVec4us
        setValue(SbVec4us self, SbVec4ub v) -> SbVec4us
        setValue(SbVec4us self, SbVec4ui32 v) -> SbVec4us
        """
        return _coin.SbVec4us_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec4us self) -> unsigned short const
        getValue(SbVec4us self, unsigned short & x, unsigned short & y, unsigned short & z, unsigned short & w)
        """
        return _coin.SbVec4us_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec4us self, SbVec4us v) -> int32_t"""
        return _coin.SbVec4us_dot(self, v)


    def negate(self):
        """negate(SbVec4us self)"""
        return _coin.SbVec4us_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec4us self, SbVec4us v) -> SbVec4us"""
        return _coin.SbVec4us___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec4us self, SbVec4us v) -> SbVec4us"""
        return _coin.SbVec4us___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec4us 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__(SoSFVec4us 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(SoSFVec4us self) -> SoType"""
        return _coin.SoSFVec4us_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec4us self, SoField field)"""
        return _coin.SoSFVec4us_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec4us self, SoField field) -> SbBool"""
        return _coin.SoSFVec4us_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec4us self) -> SbVec4us"""
        return _coin.SoSFVec4us_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec4us self, SoSFVec4us field) -> int"""
        return _coin.SoSFVec4us___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec4us self, SoSFVec4us field) -> int"""
        return _coin.SoSFVec4us___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec4us self, SbVec4us newvalue)
        setValue(SoSFVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w)
        setValue(SoSFVec4us self, unsigned short const [4] 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__(SbVec4i32 self) -> SbVec4i32
        __init__(SbVec4i32 self, int32_t const [4] v) -> SbVec4i32
        __init__(SbVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4ui32 v) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4b v) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4s v) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4f v) -> SbVec4i32
        __init__(SbVec4i32 self, SbVec4d v) -> SbVec4i32
        """
        this = _coin.new_SbVec4i32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec4i32 self, int32_t const [4] v) -> SbVec4i32
        setValue(SbVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4ui32 v) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4b v) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4s v) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4f v) -> SbVec4i32
        setValue(SbVec4i32 self, SbVec4d v) -> SbVec4i32
        """
        return _coin.SbVec4i32_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec4i32 self) -> int32_t const
        getValue(SbVec4i32 self, int32_t & x, int32_t & y, int32_t & z, int32_t & w)
        """
        return _coin.SbVec4i32_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec4i32 self, SbVec4i32 v) -> int32_t"""
        return _coin.SbVec4i32_dot(self, v)


    def negate(self):
        """negate(SbVec4i32 self)"""
        return _coin.SbVec4i32_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec4i32 self, SbVec4i32 v) -> SbVec4i32"""
        return _coin.SbVec4i32___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec4i32 self, SbVec4i32 v) -> SbVec4i32"""
        return _coin.SbVec4i32___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec4i32 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__(SoSFVec4i32 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(SoSFVec4i32 self) -> SoType"""
        return _coin.SoSFVec4i32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec4i32 self, SoField field)"""
        return _coin.SoSFVec4i32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec4i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec4i32_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec4i32 self) -> SbVec4i32"""
        return _coin.SoSFVec4i32_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec4i32 self, SoSFVec4i32 field) -> int"""
        return _coin.SoSFVec4i32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec4i32 self, SoSFVec4i32 field) -> int"""
        return _coin.SoSFVec4i32___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec4i32 self, SbVec4i32 newvalue)
        setValue(SoSFVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w)
        setValue(SoSFVec4i32 self, int32_t const [4] 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__(SbVec4ui32 self) -> SbVec4ui32
        __init__(SbVec4ui32 self, uint32_t const [4] v) -> SbVec4ui32
        __init__(SbVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w) -> SbVec4ui32
        __init__(SbVec4ui32 self, SbVec4i32 v) -> SbVec4ui32
        __init__(SbVec4ui32 self, SbVec4ub v) -> SbVec4ui32
        __init__(SbVec4ui32 self, SbVec4us v) -> SbVec4ui32
        """
        this = _coin.new_SbVec4ui32(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec4ui32 self, uint32_t const [4] v) -> SbVec4ui32
        setValue(SbVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w) -> SbVec4ui32
        setValue(SbVec4ui32 self, SbVec4i32 v) -> SbVec4ui32
        setValue(SbVec4ui32 self, SbVec4ub v) -> SbVec4ui32
        setValue(SbVec4ui32 self, SbVec4us v) -> SbVec4ui32
        """
        return _coin.SbVec4ui32_setValue(self, *args)


    def getValue(self, *args):
        """
        getValue(SbVec4ui32 self) -> uint32_t const
        getValue(SbVec4ui32 self, uint32_t & x, uint32_t & y, uint32_t & z, uint32_t & w)
        """
        return _coin.SbVec4ui32_getValue(self, *args)


    def dot(self, v):
        """dot(SbVec4ui32 self, SbVec4ui32 v) -> int32_t"""
        return _coin.SbVec4ui32_dot(self, v)


    def negate(self):
        """negate(SbVec4ui32 self)"""
        return _coin.SbVec4ui32_negate(self)


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


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


    def __iadd__(self, v):
        """__iadd__(SbVec4ui32 self, SbVec4ui32 v) -> SbVec4ui32"""
        return _coin.SbVec4ui32___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec4ui32 self, SbVec4ui32 v) -> SbVec4ui32"""
        return _coin.SbVec4ui32___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec4ui32 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__(SoSFVec4ui32 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(SoSFVec4ui32 self) -> SoType"""
        return _coin.SoSFVec4ui32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec4ui32 self, SoField field)"""
        return _coin.SoSFVec4ui32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec4ui32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec4ui32_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec4ui32 self) -> SbVec4ui32"""
        return _coin.SoSFVec4ui32_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec4ui32 self, SoSFVec4ui32 field) -> int"""
        return _coin.SoSFVec4ui32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec4ui32 self, SoSFVec4ui32 field) -> int"""
        return _coin.SoSFVec4ui32___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec4ui32 self, SbVec4ui32 newvalue)
        setValue(SoSFVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        setValue(SoSFVec4ui32 self, uint32_t const [4] 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__(SoSFVec4f 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(SoSFVec4f self) -> SoType"""
        return _coin.SoSFVec4f_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec4f self, SoField field)"""
        return _coin.SoSFVec4f_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec4f self, SoField field) -> SbBool"""
        return _coin.SoSFVec4f_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec4f self) -> SbVec4f"""
        return _coin.SoSFVec4f_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec4f self, SoSFVec4f field) -> int"""
        return _coin.SoSFVec4f___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec4f self, SoSFVec4f field) -> int"""
        return _coin.SoSFVec4f___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec4f self, SbVec4f newvalue)
        setValue(SoSFVec4f self, float x, float y, float z, float w)
        setValue(SoSFVec4f self, float const [4] xyzw)
        setValue(SoSFVec4f 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__(SbVec4d self) -> SbVec4d
        __init__(SbVec4d self, double const [4] v) -> SbVec4d
        __init__(SbVec4d self, double x, double y, double z, double w) -> SbVec4d
        __init__(SbVec4d self, SbVec4f v) -> SbVec4d
        __init__(SbVec4d self, SbVec4b v) -> SbVec4d
        __init__(SbVec4d self, SbVec4s v) -> SbVec4d
        __init__(SbVec4d self, SbVec4i32 v) -> SbVec4d
        """
        this = _coin.new_SbVec4d(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, *args):
        """
        setValue(SbVec4d self, double const [4] v) -> SbVec4d
        setValue(SbVec4d self, double x, double y, double z, double w) -> SbVec4d
        setValue(SbVec4d self, SbVec4f v) -> SbVec4d
        setValue(SbVec4d self, SbVec4b v) -> SbVec4d
        setValue(SbVec4d self, SbVec4s v) -> SbVec4d
        setValue(SbVec4d self, SbVec4i32 v) -> SbVec4d
        """
        return _coin.SbVec4d_setValue(self, *args)


    def getValue(self):
        """getValue(SbVec4d self) -> double const *"""
        return _coin.SbVec4d_getValue(self)


    def dot(self, v):
        """dot(SbVec4d self, SbVec4d v) -> double"""
        return _coin.SbVec4d_dot(self, v)


    def equals(self, v, tolerance):
        """equals(SbVec4d self, SbVec4d v, double tolerance) -> SbBool"""
        return _coin.SbVec4d_equals(self, v, tolerance)


    def getReal(self, v):
        """getReal(SbVec4d self, SbVec3d v)"""
        return _coin.SbVec4d_getReal(self, v)


    def length(self):
        """length(SbVec4d self) -> double"""
        return _coin.SbVec4d_length(self)


    def sqrLength(self):
        """sqrLength(SbVec4d self) -> double"""
        return _coin.SbVec4d_sqrLength(self)


    def negate(self):
        """negate(SbVec4d self)"""
        return _coin.SbVec4d_negate(self)


    def normalize(self):
        """normalize(SbVec4d self) -> double"""
        return _coin.SbVec4d_normalize(self)


    def __imul__(self, d):
        """__imul__(SbVec4d self, double d) -> SbVec4d"""
        return _coin.SbVec4d___imul__(self, d)


    def __idiv__(self, d):
        """__idiv__(SbVec4d self, double d) -> SbVec4d"""
        return _coin.SbVec4d___idiv__(self, d)


    def __iadd__(self, v):
        """__iadd__(SbVec4d self, SbVec4d v) -> SbVec4d"""
        return _coin.SbVec4d___iadd__(self, v)


    def __isub__(self, v):
        """__isub__(SbVec4d self, SbVec4d v) -> SbVec4d"""
        return _coin.SbVec4d___isub__(self, v)


    def __neg__(self):
        """__neg__(SbVec4d self) -> SbVec4d"""
        return _coin.SbVec4d___neg__(self)


    def output(self, fp):
        """output(SbVec4d self, FILE * fp)"""
        return _coin.SbVec4d_output(self, fp)


    def __add__(self, u):
        """__add__(SbVec4d self, SbVec4d u) -> SbVec4d"""
        return _coin.SbVec4d___add__(self, u)


    def __sub__(self, u):
        """__sub__(SbVec4d self, SbVec4d u) -> SbVec4d"""
        return _coin.SbVec4d___sub__(self, u)


    def __mul__(self, *args):
        """
        __mul__(SbVec4d self, double const d) -> SbVec4d
        __mul__(SbVec4d self, SbDPMatrix m) -> SbVec4d
        """
        return _coin.SbVec4d___mul__(self, *args)


    def __rmul__(self, d):
        """__rmul__(SbVec4d self, double const d) -> SbVec4d"""
        return _coin.SbVec4d___rmul__(self, d)


    def __div__(self, d):
        """__div__(SbVec4d self, double const d) -> SbVec4d"""
        return _coin.SbVec4d___div__(self, d)


    def __eq__(self, u):
        """__eq__(SbVec4d self, SbVec4d u) -> int"""
        return _coin.SbVec4d___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbVec4d self, SbVec4d u) -> int"""
        return _coin.SbVec4d___nq__(self, u)


    def __getitem__(self, i):
        """__getitem__(SbVec4d self, int i) -> double"""
        return _coin.SbVec4d___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SbVec4d self, int i, double value)"""
        return _coin.SbVec4d___setitem__(self, i, value)


    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__(SoSFVec4d 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(SoSFVec4d self) -> SoType"""
        return _coin.SoSFVec4d_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoSFVec4d self, SoField field)"""
        return _coin.SoSFVec4d_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoSFVec4d self, SoField field) -> SbBool"""
        return _coin.SoSFVec4d_isSame(self, field)


    def getValue(self):
        """getValue(SoSFVec4d self) -> SbVec4d"""
        return _coin.SoSFVec4d_getValue(self)


    def __eq__(self, field):
        """__eq__(SoSFVec4d self, SoSFVec4d field) -> int"""
        return _coin.SoSFVec4d___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoSFVec4d self, SoSFVec4d field) -> int"""
        return _coin.SoSFVec4d___ne__(self, field)


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

    initClass = staticmethod(initClass)

    def setValue(self, *args):
        """
        setValue(SoSFVec4d self, SbVec4d newvalue)
        setValue(SoSFVec4d self, double x, double y, double z, double w)
        setValue(SoSFVec4d self, double const [4] 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__(SoMFColor 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(SoMFColor self) -> SoType"""
        return _coin.SoMFColor_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFColor self, SoField field)"""
        return _coin.SoMFColor_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFColor self, SoField field) -> SbBool"""
        return _coin.SoMFColor_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFColor self, SbColor value, SbBool addifnotfound=0) -> int
        find(SoMFColor self, SbColor value) -> int
        """
        return _coin.SoMFColor_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFColor self, SoMFColor field) -> SbBool"""
        return _coin.SoMFColor___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFColor self, SoMFColor field) -> SbBool"""
        return _coin.SoMFColor___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFColor self) -> SbColor"""
        return _coin.SoMFColor_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFColor self)"""
        return _coin.SoMFColor_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFColor self, int const num, float const * userdata)
        setValuesPointer(SoMFColor self, int const num, float * userdata)
        setValuesPointer(SoMFColor self, int const num, SbColor userdata)
        setValuesPointer(SoMFColor self, int const 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, start, num, hsv):
        """setHSVValues(SoMFColor self, int start, int num, float const [][3] hsv)"""
        return _coin.SoMFColor_setHSVValues(self, start, num, hsv)


    def setHSVValue(self, *args):
        """
        setHSVValue(SoMFColor self, float h, float s, float v)
        setHSVValue(SoMFColor self, float const [3] hsv)
        """
        return _coin.SoMFColor_setHSVValue(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFColor self, int const idx, SbColor value)
        set1Value(SoMFColor self, int idx, SbVec3f vec)
        set1Value(SoMFColor self, int idx, float r, float g, float b)
        set1Value(SoMFColor self, int idx, float const [3] rgb)
        """
        return _coin.SoMFColor_set1Value(self, *args)


    def set1HSVValue(self, *args):
        """
        set1HSVValue(SoMFColor self, int idx, float h, float s, float v)
        set1HSVValue(SoMFColor self, int idx, float const [3] hsv)
        """
        return _coin.SoMFColor_set1HSVValue(self, *args)


    def __getitem__(self, i):
        """__getitem__(SoMFColor self, int i) -> SbColor"""
        return _coin.SoMFColor___getitem__(self, i)


    def __setitem__(self, *args):
        """
        __setitem__(SoMFColor self, int i, SbColor value)
        __setitem__(SoMFColor self, int i, float const [3] rgb)
        """
        return _coin.SoMFColor___setitem__(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFColor self, SbColor value)
        setValue(SoMFColor self, SbVec3f vec)
        setValue(SoMFColor self, float r, float g, float b)
        setValue(SoMFColor self, float const [3] rgb)
        setValue(SoMFColor self, SoMFColor other)
        """
        return _coin.SoMFColor_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFColor self, int i=0) -> SbColor
        getValues(SoMFColor 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__(SoMFColorRGBA 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(SoMFColorRGBA self) -> SoType"""
        return _coin.SoMFColorRGBA_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFColorRGBA self, SoField field)"""
        return _coin.SoMFColorRGBA_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFColorRGBA self, SoField field) -> SbBool"""
        return _coin.SoMFColorRGBA_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFColorRGBA self, int const start) -> SbColor4f"""
        return _coin.SoMFColorRGBA_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFColorRGBA self, SbColor4f value, SbBool addifnotfound=0) -> int
        find(SoMFColorRGBA self, SbColor4f value) -> int
        """
        return _coin.SoMFColorRGBA_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFColorRGBA self, SoMFColorRGBA field) -> SbBool"""
        return _coin.SoMFColorRGBA___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFColorRGBA self, SoMFColorRGBA field) -> SbBool"""
        return _coin.SoMFColorRGBA___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFColorRGBA self) -> SbColor4f"""
        return _coin.SoMFColorRGBA_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFColorRGBA self)"""
        return _coin.SoMFColorRGBA_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFColorRGBA self, int const num, float const * userdata)
        setValuesPointer(SoMFColorRGBA self, int const num, float * userdata)
        setValuesPointer(SoMFColorRGBA self, int const num, SbColor4f userdata)
        setValuesPointer(SoMFColorRGBA self, int const num, SbColor4f userdata)
        """
        return _coin.SoMFColorRGBA_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def setValues(self, *args):
        """
        setValues(SoMFColorRGBA self, int const start, int const num, SbColor4f newvals)
        setValues(SoMFColorRGBA self, int start, int num, float const [][4] rgba)
        """
        return _coin.SoMFColorRGBA_setValues(self, *args)


    def setHSVValues(self, start, num, hsv):
        """setHSVValues(SoMFColorRGBA self, int start, int num, float const [][4] hsv)"""
        return _coin.SoMFColorRGBA_setHSVValues(self, start, num, hsv)


    def setValue(self, *args):
        """
        setValue(SoMFColorRGBA self, SbColor4f value)
        setValue(SoMFColorRGBA self, SbVec4f vec)
        setValue(SoMFColorRGBA self, float r, float g, float b, float a)
        setValue(SoMFColorRGBA self, float const [4] rgba)
        """
        return _coin.SoMFColorRGBA_setValue(self, *args)


    def setHSVValue(self, *args):
        """
        setHSVValue(SoMFColorRGBA self, float h, float s, float v, float a)
        setHSVValue(SoMFColorRGBA self, float const [4] hsva)
        """
        return _coin.SoMFColorRGBA_setHSVValue(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFColorRGBA self, int const idx, SbColor4f value)
        set1Value(SoMFColorRGBA self, int idx, SbVec4f vec)
        set1Value(SoMFColorRGBA self, int idx, float r, float g, float b, float a)
        set1Value(SoMFColorRGBA self, int idx, float const [4] rgba)
        """
        return _coin.SoMFColorRGBA_set1Value(self, *args)


    def set1HSVValue(self, *args):
        """
        set1HSVValue(SoMFColorRGBA self, int idx, float h, float s, float v, float a)
        set1HSVValue(SoMFColorRGBA self, int idx, float const [4] 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__(SoMFDouble 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(SoMFDouble self) -> SoType"""
        return _coin.SoMFDouble_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFDouble self, SoField field)"""
        return _coin.SoMFDouble_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFDouble self, SoField field) -> SbBool"""
        return _coin.SoMFDouble_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFDouble self, int const start) -> double const *"""
        return _coin.SoMFDouble_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFDouble self, double value, SbBool addifnotfound=0) -> int
        find(SoMFDouble self, double value) -> int
        """
        return _coin.SoMFDouble_find(self, value, addifnotfound)


    def setValues(self, start, num, newvals):
        """setValues(SoMFDouble self, int const start, int const num, double const * newvals)"""
        return _coin.SoMFDouble_setValues(self, start, num, newvals)


    def set1Value(self, idx, value):
        """set1Value(SoMFDouble self, int const idx, double value)"""
        return _coin.SoMFDouble_set1Value(self, idx, value)


    def setValue(self, value):
        """setValue(SoMFDouble self, double value)"""
        return _coin.SoMFDouble_setValue(self, value)


    def __eq__(self, field):
        """__eq__(SoMFDouble self, SoMFDouble field) -> SbBool"""
        return _coin.SoMFDouble___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFDouble self, SoMFDouble field) -> SbBool"""
        return _coin.SoMFDouble___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFDouble self) -> double *"""
        return _coin.SoMFDouble_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFDouble self)"""
        return _coin.SoMFDouble_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFDouble self, int const num, double const * userdata)
        setValuesPointer(SoMFDouble self, int const 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__(SoMFEngine 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(SoMFEngine self) -> SoType"""
        return _coin.SoMFEngine_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFEngine self, SoField field)"""
        return _coin.SoMFEngine_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFEngine self, SoField field) -> SbBool"""
        return _coin.SoMFEngine_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFEngine self, SoEngine value, SbBool addifnotfound=0) -> int
        find(SoMFEngine self, SoEngine value) -> int
        """
        return _coin.SoMFEngine_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFEngine self, int const idx, SoEngine value)"""
        return _coin.SoMFEngine_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFEngine self, SoMFEngine field) -> SbBool"""
        return _coin.SoMFEngine___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFEngine self, SoMFEngine field) -> SbBool"""
        return _coin.SoMFEngine___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFEngine self) -> SoEngine **"""
        return _coin.SoMFEngine_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFEngine self)"""
        return _coin.SoMFEngine_finishEditing(self)


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

    initClass = staticmethod(initClass)

    def fixCopy(self, copyconnections):
        """fixCopy(SoMFEngine self, SbBool copyconnections)"""
        return _coin.SoMFEngine_fixCopy(self, copyconnections)


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


    def deleteValues(self, start, num=-1):
        """
        deleteValues(SoMFEngine self, int start, int num=-1)
        deleteValues(SoMFEngine self, int start)
        """
        return _coin.SoMFEngine_deleteValues(self, start, num)


    def insertSpace(self, start, num):
        """insertSpace(SoMFEngine self, int start, int num)"""
        return _coin.SoMFEngine_insertSpace(self, start, num)


    def __getitem__(self, i):
        """__getitem__(SoMFEngine self, int i) -> SoEngine"""
        return _coin.SoMFEngine___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFEngine self, int i, SoEngine value)"""
        return _coin.SoMFEngine___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFEngine self, SoEngine value)
        setValue(SoMFEngine self, SoMFEngine other)
        """
        return _coin.SoMFEngine_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFEngine self, int i=0) -> SoEngine
        getValues(SoMFEngine self) -> SoEngine const **
        """
        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__(SoMFBitMask 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(SoMFBitMask self) -> SoType"""
        return _coin.SoMFBitMask_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFBitMask self, SoField field)"""
        return _coin.SoMFBitMask_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFBitMask self, SoField field) -> SbBool"""
        return _coin.SoMFBitMask_isSame(self, field)


    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__(SoMFInt32 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(SoMFInt32 self) -> SoType"""
        return _coin.SoMFInt32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFInt32 self, SoField field)"""
        return _coin.SoMFInt32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFInt32 self, SoField field) -> SbBool"""
        return _coin.SoMFInt32_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFInt32 self, int32_t value, SbBool addifnotfound=0) -> int
        find(SoMFInt32 self, int32_t value) -> int
        """
        return _coin.SoMFInt32_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFInt32 self, int const idx, int32_t value)"""
        return _coin.SoMFInt32_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFInt32 self, SoMFInt32 field) -> SbBool"""
        return _coin.SoMFInt32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFInt32 self, SoMFInt32 field) -> SbBool"""
        return _coin.SoMFInt32___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFInt32 self) -> int32_t *"""
        return _coin.SoMFInt32_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFInt32 self)"""
        return _coin.SoMFInt32_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFInt32 self, int const num, int32_t const * userdata)
        setValuesPointer(SoMFInt32 self, int const num, int32_t * userdata)
        """
        return _coin.SoMFInt32_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def __getitem__(self, i):
        """__getitem__(SoMFInt32 self, int i) -> int32_t const"""
        return _coin.SoMFInt32___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFInt32 self, int i, int32_t value)"""
        return _coin.SoMFInt32___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFInt32 self, int32_t value)
        setValue(SoMFInt32 self, SoMFInt32 other)
        """
        return _coin.SoMFInt32_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFInt32 self, int32_t i=0) -> int32_t const
        getValues(SoMFInt32 self) -> int32_t const *
        """
        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__(SoMFNode 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(SoMFNode self) -> SoType"""
        return _coin.SoMFNode_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFNode self, SoField field)"""
        return _coin.SoMFNode_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFNode self, SoField field) -> SbBool"""
        return _coin.SoMFNode_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFNode self, SoNode value, SbBool addifnotfound=0) -> int
        find(SoMFNode self, SoNode value) -> int
        """
        return _coin.SoMFNode_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFNode self, int const idx, SoNode value)"""
        return _coin.SoMFNode_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFNode self, SoMFNode field) -> SbBool"""
        return _coin.SoMFNode___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFNode self, SoMFNode field) -> SbBool"""
        return _coin.SoMFNode___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFNode self) -> SoNode **"""
        return _coin.SoMFNode_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFNode self)"""
        return _coin.SoMFNode_finishEditing(self)


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

    initClass = staticmethod(initClass)

    def fixCopy(self, copyconnections):
        """fixCopy(SoMFNode self, SbBool copyconnections)"""
        return _coin.SoMFNode_fixCopy(self, copyconnections)


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


    def addNode(self, node):
        """addNode(SoMFNode self, SoNode node)"""
        return _coin.SoMFNode_addNode(self, node)


    def insertNode(self, node, idx):
        """insertNode(SoMFNode self, SoNode node, int idx)"""
        return _coin.SoMFNode_insertNode(self, node, idx)


    def getNode(self, idx):
        """getNode(SoMFNode self, int idx) -> SoNode"""
        return _coin.SoMFNode_getNode(self, idx)


    def findNode(self, node):
        """findNode(SoMFNode self, SoNode node) -> int"""
        return _coin.SoMFNode_findNode(self, node)


    def getNumNodes(self):
        """getNumNodes(SoMFNode self) -> int"""
        return _coin.SoMFNode_getNumNodes(self)


    def removeNode(self, *args):
        """
        removeNode(SoMFNode self, int index)
        removeNode(SoMFNode self, SoNode node)
        """
        return _coin.SoMFNode_removeNode(self, *args)


    def removeAllNodes(self):
        """removeAllNodes(SoMFNode self)"""
        return _coin.SoMFNode_removeAllNodes(self)


    def replaceNode(self, *args):
        """
        replaceNode(SoMFNode self, int idx, SoNode newnode)
        replaceNode(SoMFNode self, SoNode oldnode, SoNode newnode)
        """
        return _coin.SoMFNode_replaceNode(self, *args)


    def deleteValues(self, start, num=-1):
        """
        deleteValues(SoMFNode self, int start, int num=-1)
        deleteValues(SoMFNode self, int start)
        """
        return _coin.SoMFNode_deleteValues(self, start, num)


    def insertSpace(self, start, num):
        """insertSpace(SoMFNode self, int start, int num)"""
        return _coin.SoMFNode_insertSpace(self, start, num)


    def __getitem__(self, i):
        """__getitem__(SoMFNode self, int i) -> SoNode"""
        return _coin.SoMFNode___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFNode self, int i, SoNode value)"""
        return _coin.SoMFNode___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFNode self, SoNode value)
        setValue(SoMFNode self, SoMFNode other)
        """
        return _coin.SoMFNode_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFNode self, int i=0) -> SoNode
        getValues(SoMFNode self) -> SoNode const **
        """
        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__(SoMFPath 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(SoMFPath self) -> SoType"""
        return _coin.SoMFPath_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFPath self, SoField field)"""
        return _coin.SoMFPath_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFPath self, SoField field) -> SbBool"""
        return _coin.SoMFPath_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFPath self, SoPath value, SbBool addifnotfound=0) -> int
        find(SoMFPath self, SoPath value) -> int
        """
        return _coin.SoMFPath_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFPath self, int const idx, SoPath value)"""
        return _coin.SoMFPath_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFPath self, SoMFPath field) -> SbBool"""
        return _coin.SoMFPath___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFPath self, SoMFPath field) -> SbBool"""
        return _coin.SoMFPath___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFPath self) -> SoPath **"""
        return _coin.SoMFPath_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFPath self)"""
        return _coin.SoMFPath_finishEditing(self)


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

    initClass = staticmethod(initClass)

    def notify(self, l):
        """notify(SoMFPath self, SoNotList l)"""
        return _coin.SoMFPath_notify(self, l)


    def fixCopy(self, copyconnections):
        """fixCopy(SoMFPath self, SbBool copyconnections)"""
        return _coin.SoMFPath_fixCopy(self, copyconnections)


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


    def deleteValues(self, start, num=-1):
        """
        deleteValues(SoMFPath self, int start, int num=-1)
        deleteValues(SoMFPath self, int start)
        """
        return _coin.SoMFPath_deleteValues(self, start, num)


    def insertSpace(self, start, num):
        """insertSpace(SoMFPath self, int start, int num)"""
        return _coin.SoMFPath_insertSpace(self, start, num)


    def __getitem__(self, i):
        """__getitem__(SoMFPath self, int i) -> SoPath"""
        return _coin.SoMFPath___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFPath self, int i, SoPath value)"""
        return _coin.SoMFPath___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFPath self, SoPath value)
        setValue(SoMFPath self, SoMFPath other)
        """
        return _coin.SoMFPath_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFPath self, int i=0) -> SoPath
        getValues(SoMFPath self) -> SoPath const **
        """
        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__(SoMFPlane 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(SoMFPlane self) -> SoType"""
        return _coin.SoMFPlane_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFPlane self, SoField field)"""
        return _coin.SoMFPlane_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFPlane self, SoField field) -> SbBool"""
        return _coin.SoMFPlane_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFPlane self, SbPlane value, SbBool addifnotfound=0) -> int
        find(SoMFPlane self, SbPlane value) -> int
        """
        return _coin.SoMFPlane_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFPlane self, int const idx, SbPlane value)"""
        return _coin.SoMFPlane_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFPlane self, SoMFPlane field) -> SbBool"""
        return _coin.SoMFPlane___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFPlane self, SoMFPlane field) -> SbBool"""
        return _coin.SoMFPlane___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFPlane self) -> SbPlane"""
        return _coin.SoMFPlane_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFPlane self)"""
        return _coin.SoMFPlane_finishEditing(self)


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

    initClass = staticmethod(initClass)

    def __getitem__(self, i):
        """__getitem__(SoMFPlane self, int i) -> SbPlane"""
        return _coin.SoMFPlane___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFPlane self, int i, SbPlane value)"""
        return _coin.SoMFPlane___setitem__(self, i, value)


    def getValues(self, i=0):
        """
        getValues(SoMFPlane self, int i=0) -> SbPlane
        getValues(SoMFPlane self) -> SbPlane
        """
        return _coin.SoMFPlane_getValues(self, i)


    def setValue(self, *args):
        """
        setValue(SoMFPlane self, SbPlane value)
        setValue(SoMFPlane 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__(SoMFShort 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(SoMFShort self) -> SoType"""
        return _coin.SoMFShort_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFShort self, SoField field)"""
        return _coin.SoMFShort_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFShort self, SoField field) -> SbBool"""
        return _coin.SoMFShort_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFShort self, short value, SbBool addifnotfound=0) -> int
        find(SoMFShort self, short value) -> int
        """
        return _coin.SoMFShort_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFShort self, int const idx, short value)"""
        return _coin.SoMFShort_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFShort self, SoMFShort field) -> SbBool"""
        return _coin.SoMFShort___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFShort self, SoMFShort field) -> SbBool"""
        return _coin.SoMFShort___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFShort self) -> short *"""
        return _coin.SoMFShort_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFShort self)"""
        return _coin.SoMFShort_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFShort self, int const num, short const * userdata)
        setValuesPointer(SoMFShort self, int const num, short * userdata)
        """
        return _coin.SoMFShort_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def __getitem__(self, i):
        """__getitem__(SoMFShort self, int i) -> short const"""
        return _coin.SoMFShort___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFShort self, int i, short value)"""
        return _coin.SoMFShort___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFShort self, short value)
        setValue(SoMFShort self, SoMFShort other)
        """
        return _coin.SoMFShort_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFShort self, int i=0) -> short const
        getValues(SoMFShort self) -> short const *
        """
        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__(SoMFTime 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(SoMFTime self) -> SoType"""
        return _coin.SoMFTime_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFTime self, SoField field)"""
        return _coin.SoMFTime_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFTime self, SoField field) -> SbBool"""
        return _coin.SoMFTime_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFTime self, SbTime value, SbBool addifnotfound=0) -> int
        find(SoMFTime self, SbTime value) -> int
        """
        return _coin.SoMFTime_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFTime self, int const idx, SbTime value)"""
        return _coin.SoMFTime_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFTime self, SoMFTime field) -> SbBool"""
        return _coin.SoMFTime___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFTime self, SoMFTime field) -> SbBool"""
        return _coin.SoMFTime___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFTime self) -> SbTime"""
        return _coin.SoMFTime_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFTime self)"""
        return _coin.SoMFTime_finishEditing(self)


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

    initClass = staticmethod(initClass)

    def __getitem__(self, i):
        """__getitem__(SoMFTime self, int i) -> SbTime"""
        return _coin.SoMFTime___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFTime self, int i, SbTime value)"""
        return _coin.SoMFTime___setitem__(self, i, value)


    def getValues(self, i=0):
        """
        getValues(SoMFTime self, int i=0) -> SbTime
        getValues(SoMFTime self) -> SbTime
        """
        return _coin.SoMFTime_getValues(self, i)


    def setValue(self, *args):
        """
        setValue(SoMFTime self, SbTime value)
        setValue(SoMFTime 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__(SoMFUInt32 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(SoMFUInt32 self) -> SoType"""
        return _coin.SoMFUInt32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFUInt32 self, SoField field)"""
        return _coin.SoMFUInt32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFUInt32 self, SoField field) -> SbBool"""
        return _coin.SoMFUInt32_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFUInt32 self, uint32_t value, SbBool addifnotfound=0) -> int
        find(SoMFUInt32 self, uint32_t value) -> int
        """
        return _coin.SoMFUInt32_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFUInt32 self, int const idx, uint32_t value)"""
        return _coin.SoMFUInt32_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFUInt32 self, SoMFUInt32 field) -> SbBool"""
        return _coin.SoMFUInt32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFUInt32 self, SoMFUInt32 field) -> SbBool"""
        return _coin.SoMFUInt32___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFUInt32 self) -> uint32_t *"""
        return _coin.SoMFUInt32_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFUInt32 self)"""
        return _coin.SoMFUInt32_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFUInt32 self, int const num, uint32_t const * userdata)
        setValuesPointer(SoMFUInt32 self, int const num, uint32_t * userdata)
        """
        return _coin.SoMFUInt32_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def __getitem__(self, i):
        """__getitem__(SoMFUInt32 self, int i) -> uint32_t const"""
        return _coin.SoMFUInt32___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFUInt32 self, int i, uint32_t value)"""
        return _coin.SoMFUInt32___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFUInt32 self, uint32_t value)
        setValue(SoMFUInt32 self, SoMFUInt32 other)
        """
        return _coin.SoMFUInt32_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFUInt32 self, int i=0) -> uint32_t const
        getValues(SoMFUInt32 self) -> uint32_t const *
        """
        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__(SoMFUShort 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(SoMFUShort self) -> SoType"""
        return _coin.SoMFUShort_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFUShort self, SoField field)"""
        return _coin.SoMFUShort_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFUShort self, SoField field) -> SbBool"""
        return _coin.SoMFUShort_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFUShort self, unsigned short value, SbBool addifnotfound=0) -> int
        find(SoMFUShort self, unsigned short value) -> int
        """
        return _coin.SoMFUShort_find(self, value, addifnotfound)


    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, idx, value):
        """set1Value(SoMFUShort self, int const idx, unsigned short value)"""
        return _coin.SoMFUShort_set1Value(self, idx, value)


    def __eq__(self, field):
        """__eq__(SoMFUShort self, SoMFUShort field) -> SbBool"""
        return _coin.SoMFUShort___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFUShort self, SoMFUShort field) -> SbBool"""
        return _coin.SoMFUShort___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFUShort self) -> unsigned short *"""
        return _coin.SoMFUShort_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFUShort self)"""
        return _coin.SoMFUShort_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFUShort self, int const num, unsigned short const * userdata)
        setValuesPointer(SoMFUShort self, int const num, unsigned short * userdata)
        """
        return _coin.SoMFUShort_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def __getitem__(self, i):
        """__getitem__(SoMFUShort self, int i) -> short const"""
        return _coin.SoMFUShort___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFUShort self, int i, short value)"""
        return _coin.SoMFUShort___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFUShort self, unsigned short value)
        setValue(SoMFUShort self, SoMFUShort other)
        """
        return _coin.SoMFUShort_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFUShort self, int i=0) -> unsigned short const
        getValues(SoMFUShort self) -> unsigned short const *
        """
        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__(SoMFVec2b 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(SoMFVec2b self) -> SoType"""
        return _coin.SoMFVec2b_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec2b self, SoField field)"""
        return _coin.SoMFVec2b_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec2b self, SoField field) -> SbBool"""
        return _coin.SoMFVec2b_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec2b self, int const start) -> SbVec2b"""
        return _coin.SoMFVec2b_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec2b self, SbVec2b value, SbBool addifnotfound=0) -> int
        find(SoMFVec2b self, SbVec2b value) -> int
        """
        return _coin.SoMFVec2b_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec2b self, SoMFVec2b field) -> SbBool"""
        return _coin.SoMFVec2b___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec2b self, SoMFVec2b field) -> SbBool"""
        return _coin.SoMFVec2b___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec2b self) -> SbVec2b"""
        return _coin.SoMFVec2b_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec2b self)"""
        return _coin.SoMFVec2b_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec2b self, int const num, SbVec2b userdata)
        setValuesPointer(SoMFVec2b self, int const num, SbVec2b userdata)
        setValuesPointer(SoMFVec2b self, int const num, int8_t const * userdata)
        setValuesPointer(SoMFVec2b self, int const 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(SoMFVec2b self, int const start, int const num, SbVec2b newvals)
        setValues(SoMFVec2b self, int start, int num, int8_t const [][2] xy)
        """
        return _coin.SoMFVec2b_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec2b self, int const idx, SbVec2b value)
        set1Value(SoMFVec2b self, int idx, int8_t x, int8_t y)
        set1Value(SoMFVec2b self, int idx, int8_t const [2] xy)
        """
        return _coin.SoMFVec2b_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec2b self, SbVec2b value)
        setValue(SoMFVec2b self, int8_t x, int8_t y)
        setValue(SoMFVec2b self, int8_t const [2] 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__(SoMFVec2s 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(SoMFVec2s self) -> SoType"""
        return _coin.SoMFVec2s_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec2s self, SoField field)"""
        return _coin.SoMFVec2s_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec2s self, SoField field) -> SbBool"""
        return _coin.SoMFVec2s_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec2s self, int const start) -> SbVec2s"""
        return _coin.SoMFVec2s_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec2s self, SbVec2s value, SbBool addifnotfound=0) -> int
        find(SoMFVec2s self, SbVec2s value) -> int
        """
        return _coin.SoMFVec2s_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec2s self, SoMFVec2s field) -> SbBool"""
        return _coin.SoMFVec2s___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec2s self, SoMFVec2s field) -> SbBool"""
        return _coin.SoMFVec2s___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec2s self) -> SbVec2s"""
        return _coin.SoMFVec2s_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec2s self)"""
        return _coin.SoMFVec2s_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec2s self, int const num, SbVec2s userdata)
        setValuesPointer(SoMFVec2s self, int const num, SbVec2s userdata)
        setValuesPointer(SoMFVec2s self, int const num, short const * userdata)
        setValuesPointer(SoMFVec2s self, int const num, short * userdata)
        """
        return _coin.SoMFVec2s_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def setValues(self, *args):
        """
        setValues(SoMFVec2s self, int const start, int const num, SbVec2s newvals)
        setValues(SoMFVec2s self, int start, int num, short const [][2] xy)
        """
        return _coin.SoMFVec2s_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec2s self, int const idx, SbVec2s value)
        set1Value(SoMFVec2s self, int idx, short x, short y)
        set1Value(SoMFVec2s self, int idx, short const [2] xy)
        """
        return _coin.SoMFVec2s_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec2s self, SbVec2s value)
        setValue(SoMFVec2s self, short x, short y)
        setValue(SoMFVec2s self, short const [2] 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__(SoMFVec2i32 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(SoMFVec2i32 self) -> SoType"""
        return _coin.SoMFVec2i32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec2i32 self, SoField field)"""
        return _coin.SoMFVec2i32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec2i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec2i32_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec2i32 self, int const start) -> SbVec2i32"""
        return _coin.SoMFVec2i32_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec2i32 self, SbVec2i32 value, SbBool addifnotfound=0) -> int
        find(SoMFVec2i32 self, SbVec2i32 value) -> int
        """
        return _coin.SoMFVec2i32_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec2i32 self, SoMFVec2i32 field) -> SbBool"""
        return _coin.SoMFVec2i32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec2i32 self, SoMFVec2i32 field) -> SbBool"""
        return _coin.SoMFVec2i32___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec2i32 self) -> SbVec2i32"""
        return _coin.SoMFVec2i32_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec2i32 self)"""
        return _coin.SoMFVec2i32_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec2i32 self, int const num, SbVec2i32 userdata)
        setValuesPointer(SoMFVec2i32 self, int const num, SbVec2i32 userdata)
        setValuesPointer(SoMFVec2i32 self, int const num, int32_t const * userdata)
        setValuesPointer(SoMFVec2i32 self, int const 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(SoMFVec2i32 self, int const start, int const num, SbVec2i32 newvals)
        setValues(SoMFVec2i32 self, int start, int num, int32_t const [][2] xy)
        """
        return _coin.SoMFVec2i32_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec2i32 self, int const idx, SbVec2i32 value)
        set1Value(SoMFVec2i32 self, int idx, int32_t x, int32_t y)
        set1Value(SoMFVec2i32 self, int idx, int32_t const [2] xy)
        """
        return _coin.SoMFVec2i32_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec2i32 self, SbVec2i32 value)
        setValue(SoMFVec2i32 self, int32_t x, int32_t y)
        setValue(SoMFVec2i32 self, int32_t const [2] 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__(SoMFVec2d 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(SoMFVec2d self) -> SoType"""
        return _coin.SoMFVec2d_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec2d self, SoField field)"""
        return _coin.SoMFVec2d_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec2d self, SoField field) -> SbBool"""
        return _coin.SoMFVec2d_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec2d self, int const start) -> SbVec2d"""
        return _coin.SoMFVec2d_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec2d self, SbVec2d value, SbBool addifnotfound=0) -> int
        find(SoMFVec2d self, SbVec2d value) -> int
        """
        return _coin.SoMFVec2d_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec2d self, SoMFVec2d field) -> SbBool"""
        return _coin.SoMFVec2d___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec2d self, SoMFVec2d field) -> SbBool"""
        return _coin.SoMFVec2d___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec2d self) -> SbVec2d"""
        return _coin.SoMFVec2d_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec2d self)"""
        return _coin.SoMFVec2d_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec2d self, int const num, SbVec2d userdata)
        setValuesPointer(SoMFVec2d self, int const num, SbVec2d userdata)
        setValuesPointer(SoMFVec2d self, int const num, double const * userdata)
        setValuesPointer(SoMFVec2d self, int const num, double * userdata)
        """
        return _coin.SoMFVec2d_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def setValues(self, *args):
        """
        setValues(SoMFVec2d self, int const start, int const num, SbVec2d newvals)
        setValues(SoMFVec2d self, int start, int num, double const [][2] xy)
        """
        return _coin.SoMFVec2d_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec2d self, int const idx, SbVec2d value)
        set1Value(SoMFVec2d self, int idx, double x, double y)
        set1Value(SoMFVec2d self, int idx, double const [2] xy)
        """
        return _coin.SoMFVec2d_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec2d self, SbVec2d value)
        setValue(SoMFVec2d self, double x, double y)
        setValue(SoMFVec2d self, double const [2] 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__(SoMFVec3b 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(SoMFVec3b self) -> SoType"""
        return _coin.SoMFVec3b_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec3b self, SoField field)"""
        return _coin.SoMFVec3b_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec3b self, SoField field) -> SbBool"""
        return _coin.SoMFVec3b_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec3b self, int const start) -> SbVec3b"""
        return _coin.SoMFVec3b_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec3b self, SbVec3b value, SbBool addifnotfound=0) -> int
        find(SoMFVec3b self, SbVec3b value) -> int
        """
        return _coin.SoMFVec3b_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec3b self, SoMFVec3b field) -> SbBool"""
        return _coin.SoMFVec3b___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec3b self, SoMFVec3b field) -> SbBool"""
        return _coin.SoMFVec3b___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec3b self) -> SbVec3b"""
        return _coin.SoMFVec3b_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec3b self)"""
        return _coin.SoMFVec3b_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec3b self, int const num, SbVec3b userdata)
        setValuesPointer(SoMFVec3b self, int const num, SbVec3b userdata)
        setValuesPointer(SoMFVec3b self, int const num, int8_t const * userdata)
        setValuesPointer(SoMFVec3b self, int const 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(SoMFVec3b self, int const start, int const num, SbVec3b newvals)
        setValues(SoMFVec3b self, int start, int num, int8_t const [][3] xyz)
        """
        return _coin.SoMFVec3b_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec3b self, int const idx, SbVec3b value)
        set1Value(SoMFVec3b self, int idx, int8_t x, int8_t y, int8_t z)
        set1Value(SoMFVec3b self, int idx, int8_t const [3] xyz)
        """
        return _coin.SoMFVec3b_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec3b self, SbVec3b value)
        setValue(SoMFVec3b self, int8_t x, int8_t y, int8_t z)
        setValue(SoMFVec3b self, int8_t const [3] 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__(SoMFVec3s 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(SoMFVec3s self) -> SoType"""
        return _coin.SoMFVec3s_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec3s self, SoField field)"""
        return _coin.SoMFVec3s_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec3s self, SoField field) -> SbBool"""
        return _coin.SoMFVec3s_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec3s self, int const start) -> SbVec3s"""
        return _coin.SoMFVec3s_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec3s self, SbVec3s value, SbBool addifnotfound=0) -> int
        find(SoMFVec3s self, SbVec3s value) -> int
        """
        return _coin.SoMFVec3s_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec3s self, SoMFVec3s field) -> SbBool"""
        return _coin.SoMFVec3s___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec3s self, SoMFVec3s field) -> SbBool"""
        return _coin.SoMFVec3s___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec3s self) -> SbVec3s"""
        return _coin.SoMFVec3s_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec3s self)"""
        return _coin.SoMFVec3s_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec3s self, int const num, SbVec3s userdata)
        setValuesPointer(SoMFVec3s self, int const num, SbVec3s userdata)
        setValuesPointer(SoMFVec3s self, int const num, short const * userdata)
        setValuesPointer(SoMFVec3s self, int const num, short * userdata)
        """
        return _coin.SoMFVec3s_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def setValues(self, *args):
        """
        setValues(SoMFVec3s self, int const start, int const num, SbVec3s newvals)
        setValues(SoMFVec3s self, int start, int num, short const [][3] xyz)
        """
        return _coin.SoMFVec3s_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec3s self, int const idx, SbVec3s value)
        set1Value(SoMFVec3s self, int idx, short x, short y, short z)
        set1Value(SoMFVec3s self, int idx, short const [3] xyz)
        """
        return _coin.SoMFVec3s_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec3s self, SbVec3s value)
        setValue(SoMFVec3s self, short x, short y, short z)
        setValue(SoMFVec3s self, short const [3] 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__(SoMFVec3i32 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(SoMFVec3i32 self) -> SoType"""
        return _coin.SoMFVec3i32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec3i32 self, SoField field)"""
        return _coin.SoMFVec3i32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec3i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec3i32_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec3i32 self, int const start) -> SbVec3i32"""
        return _coin.SoMFVec3i32_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec3i32 self, SbVec3i32 value, SbBool addifnotfound=0) -> int
        find(SoMFVec3i32 self, SbVec3i32 value) -> int
        """
        return _coin.SoMFVec3i32_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec3i32 self, SoMFVec3i32 field) -> SbBool"""
        return _coin.SoMFVec3i32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec3i32 self, SoMFVec3i32 field) -> SbBool"""
        return _coin.SoMFVec3i32___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec3i32 self) -> SbVec3i32"""
        return _coin.SoMFVec3i32_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec3i32 self)"""
        return _coin.SoMFVec3i32_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec3i32 self, int const num, SbVec3i32 userdata)
        setValuesPointer(SoMFVec3i32 self, int const num, SbVec3i32 userdata)
        setValuesPointer(SoMFVec3i32 self, int const num, int32_t const * userdata)
        setValuesPointer(SoMFVec3i32 self, int const 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(SoMFVec3i32 self, int const start, int const num, SbVec3i32 newvals)
        setValues(SoMFVec3i32 self, int start, int num, int32_t const [][3] xyz)
        """
        return _coin.SoMFVec3i32_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec3i32 self, int const idx, SbVec3i32 value)
        set1Value(SoMFVec3i32 self, int idx, int32_t x, int32_t y, int32_t z)
        set1Value(SoMFVec3i32 self, int idx, int32_t const [3] xyz)
        """
        return _coin.SoMFVec3i32_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec3i32 self, SbVec3i32 value)
        setValue(SoMFVec3i32 self, int32_t x, int32_t y, int32_t z)
        setValue(SoMFVec3i32 self, int32_t const [3] 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__(SoMFVec3d 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(SoMFVec3d self) -> SoType"""
        return _coin.SoMFVec3d_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec3d self, SoField field)"""
        return _coin.SoMFVec3d_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec3d self, SoField field) -> SbBool"""
        return _coin.SoMFVec3d_isSame(self, field)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec3d self, SbVec3d value, SbBool addifnotfound=0) -> int
        find(SoMFVec3d self, SbVec3d value) -> int
        """
        return _coin.SoMFVec3d_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec3d self, SoMFVec3d field) -> SbBool"""
        return _coin.SoMFVec3d___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec3d self, SoMFVec3d field) -> SbBool"""
        return _coin.SoMFVec3d___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec3d self) -> SbVec3d"""
        return _coin.SoMFVec3d_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec3d self)"""
        return _coin.SoMFVec3d_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec3d self, int const num, SbVec3d userdata)
        setValuesPointer(SoMFVec3d self, int const num, SbVec3d userdata)
        setValuesPointer(SoMFVec3d self, int const num, double const * userdata)
        setValuesPointer(SoMFVec3d self, int const 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(SoMFVec3d self, int const idx, SbVec3d value)
        set1Value(SoMFVec3d self, int idx, double x, double y, double z)
        set1Value(SoMFVec3d self, int idx, double const [3] xyz)
        """
        return _coin.SoMFVec3d_set1Value(self, *args)


    def __getitem__(self, i):
        """__getitem__(SoMFVec3d self, int i) -> SbVec3d"""
        return _coin.SoMFVec3d___getitem__(self, i)


    def __setitem__(self, i, value):
        """__setitem__(SoMFVec3d self, int i, SbVec3d value)"""
        return _coin.SoMFVec3d___setitem__(self, i, value)


    def setValue(self, *args):
        """
        setValue(SoMFVec3d self, SbVec3d value)
        setValue(SoMFVec3d self, double x, double y, double z)
        setValue(SoMFVec3d self, double const [3] xyz)
        setValue(SoMFVec3d self, SoMFVec3d other)
        """
        return _coin.SoMFVec3d_setValue(self, *args)


    def getValues(self, i=0):
        """
        getValues(SoMFVec3d self, int i=0) -> SbVec3d
        getValues(SoMFVec3d 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__(SoMFVec4b 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(SoMFVec4b self) -> SoType"""
        return _coin.SoMFVec4b_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec4b self, SoField field)"""
        return _coin.SoMFVec4b_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec4b self, SoField field) -> SbBool"""
        return _coin.SoMFVec4b_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec4b self, int const start) -> SbVec4b"""
        return _coin.SoMFVec4b_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec4b self, SbVec4b value, SbBool addifnotfound=0) -> int
        find(SoMFVec4b self, SbVec4b value) -> int
        """
        return _coin.SoMFVec4b_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec4b self, SoMFVec4b field) -> SbBool"""
        return _coin.SoMFVec4b___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec4b self, SoMFVec4b field) -> SbBool"""
        return _coin.SoMFVec4b___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec4b self) -> SbVec4b"""
        return _coin.SoMFVec4b_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec4b self)"""
        return _coin.SoMFVec4b_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec4b self, int const num, SbVec4b userdata)
        setValuesPointer(SoMFVec4b self, int const num, SbVec4b userdata)
        setValuesPointer(SoMFVec4b self, int const num, int8_t const * userdata)
        setValuesPointer(SoMFVec4b self, int const 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(SoMFVec4b self, int const start, int const num, SbVec4b newvals)
        setValues(SoMFVec4b self, int start, int num, int8_t const [][4] xyzw)
        """
        return _coin.SoMFVec4b_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec4b self, int const idx, SbVec4b value)
        set1Value(SoMFVec4b self, int idx, int8_t x, int8_t y, int8_t z, int8_t w)
        set1Value(SoMFVec4b self, int idx, int8_t const [4] xyzw)
        """
        return _coin.SoMFVec4b_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec4b self, SbVec4b value)
        setValue(SoMFVec4b self, int8_t x, int8_t y, int8_t z, int8_t w)
        setValue(SoMFVec4b self, int8_t const [4] 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__(SoMFVec4ub 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(SoMFVec4ub self) -> SoType"""
        return _coin.SoMFVec4ub_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec4ub self, SoField field)"""
        return _coin.SoMFVec4ub_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec4ub self, SoField field) -> SbBool"""
        return _coin.SoMFVec4ub_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec4ub self, int const start) -> SbVec4ub"""
        return _coin.SoMFVec4ub_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec4ub self, SbVec4ub value, SbBool addifnotfound=0) -> int
        find(SoMFVec4ub self, SbVec4ub value) -> int
        """
        return _coin.SoMFVec4ub_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec4ub self, SoMFVec4ub field) -> SbBool"""
        return _coin.SoMFVec4ub___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec4ub self, SoMFVec4ub field) -> SbBool"""
        return _coin.SoMFVec4ub___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec4ub self) -> SbVec4ub"""
        return _coin.SoMFVec4ub_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec4ub self)"""
        return _coin.SoMFVec4ub_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec4ub self, int const num, SbVec4ub userdata)
        setValuesPointer(SoMFVec4ub self, int const num, SbVec4ub userdata)
        setValuesPointer(SoMFVec4ub self, int const num, uint8_t const * userdata)
        setValuesPointer(SoMFVec4ub self, int const 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(SoMFVec4ub self, int const start, int const num, SbVec4ub newvals)
        setValues(SoMFVec4ub self, int start, int num, uint8_t const [][4] xyzw)
        """
        return _coin.SoMFVec4ub_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec4ub self, int const idx, SbVec4ub value)
        set1Value(SoMFVec4ub self, int idx, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        set1Value(SoMFVec4ub self, int idx, uint8_t const [4] xyzw)
        """
        return _coin.SoMFVec4ub_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec4ub self, SbVec4ub value)
        setValue(SoMFVec4ub self, uint8_t x, uint8_t y, uint8_t z, uint8_t w)
        setValue(SoMFVec4ub self, uint8_t const [4] 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__(SoMFVec4s 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(SoMFVec4s self) -> SoType"""
        return _coin.SoMFVec4s_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec4s self, SoField field)"""
        return _coin.SoMFVec4s_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec4s self, SoField field) -> SbBool"""
        return _coin.SoMFVec4s_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec4s self, int const start) -> SbVec4s"""
        return _coin.SoMFVec4s_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec4s self, SbVec4s value, SbBool addifnotfound=0) -> int
        find(SoMFVec4s self, SbVec4s value) -> int
        """
        return _coin.SoMFVec4s_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec4s self, SoMFVec4s field) -> SbBool"""
        return _coin.SoMFVec4s___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec4s self, SoMFVec4s field) -> SbBool"""
        return _coin.SoMFVec4s___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec4s self) -> SbVec4s"""
        return _coin.SoMFVec4s_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec4s self)"""
        return _coin.SoMFVec4s_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec4s self, int const num, SbVec4s userdata)
        setValuesPointer(SoMFVec4s self, int const num, SbVec4s userdata)
        setValuesPointer(SoMFVec4s self, int const num, short const * userdata)
        setValuesPointer(SoMFVec4s self, int const num, short * userdata)
        """
        return _coin.SoMFVec4s_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def setValues(self, *args):
        """
        setValues(SoMFVec4s self, int const start, int const num, SbVec4s newvals)
        setValues(SoMFVec4s self, int start, int num, short const [][4] xyzw)
        """
        return _coin.SoMFVec4s_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec4s self, int const idx, SbVec4s value)
        set1Value(SoMFVec4s self, int idx, short x, short y, short z, short w)
        set1Value(SoMFVec4s self, int idx, short const [4] xyzw)
        """
        return _coin.SoMFVec4s_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec4s self, SbVec4s value)
        setValue(SoMFVec4s self, short x, short y, short z, short w)
        setValue(SoMFVec4s self, short const [4] 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__(SoMFVec4us 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(SoMFVec4us self) -> SoType"""
        return _coin.SoMFVec4us_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec4us self, SoField field)"""
        return _coin.SoMFVec4us_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec4us self, SoField field) -> SbBool"""
        return _coin.SoMFVec4us_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec4us self, int const start) -> SbVec4us"""
        return _coin.SoMFVec4us_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec4us self, SbVec4us value, SbBool addifnotfound=0) -> int
        find(SoMFVec4us self, SbVec4us value) -> int
        """
        return _coin.SoMFVec4us_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec4us self, SoMFVec4us field) -> SbBool"""
        return _coin.SoMFVec4us___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec4us self, SoMFVec4us field) -> SbBool"""
        return _coin.SoMFVec4us___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec4us self) -> SbVec4us"""
        return _coin.SoMFVec4us_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec4us self)"""
        return _coin.SoMFVec4us_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec4us self, int const num, SbVec4us userdata)
        setValuesPointer(SoMFVec4us self, int const num, SbVec4us userdata)
        setValuesPointer(SoMFVec4us self, int const num, unsigned short const * userdata)
        setValuesPointer(SoMFVec4us self, int const 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(SoMFVec4us self, int const start, int const num, SbVec4us newvals)
        setValues(SoMFVec4us self, int start, int num, unsigned short const [][4] xyzw)
        """
        return _coin.SoMFVec4us_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec4us self, int const idx, SbVec4us value)
        set1Value(SoMFVec4us self, int idx, unsigned short x, unsigned short y, unsigned short z, unsigned short w)
        set1Value(SoMFVec4us self, int idx, unsigned short const [4] xyzw)
        """
        return _coin.SoMFVec4us_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec4us self, SbVec4us value)
        setValue(SoMFVec4us self, unsigned short x, unsigned short y, unsigned short z, unsigned short w)
        setValue(SoMFVec4us self, unsigned short const [4] 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__(SoMFVec4i32 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(SoMFVec4i32 self) -> SoType"""
        return _coin.SoMFVec4i32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec4i32 self, SoField field)"""
        return _coin.SoMFVec4i32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec4i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec4i32_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec4i32 self, int const start) -> SbVec4i32"""
        return _coin.SoMFVec4i32_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec4i32 self, SbVec4i32 value, SbBool addifnotfound=0) -> int
        find(SoMFVec4i32 self, SbVec4i32 value) -> int
        """
        return _coin.SoMFVec4i32_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec4i32 self, SoMFVec4i32 field) -> SbBool"""
        return _coin.SoMFVec4i32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec4i32 self, SoMFVec4i32 field) -> SbBool"""
        return _coin.SoMFVec4i32___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec4i32 self) -> SbVec4i32"""
        return _coin.SoMFVec4i32_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec4i32 self)"""
        return _coin.SoMFVec4i32_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec4i32 self, int const num, SbVec4i32 userdata)
        setValuesPointer(SoMFVec4i32 self, int const num, SbVec4i32 userdata)
        setValuesPointer(SoMFVec4i32 self, int const num, int32_t const * userdata)
        setValuesPointer(SoMFVec4i32 self, int const 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(SoMFVec4i32 self, int const start, int const num, SbVec4i32 newvals)
        setValues(SoMFVec4i32 self, int start, int num, int32_t const [][4] xyzw)
        """
        return _coin.SoMFVec4i32_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec4i32 self, int const idx, SbVec4i32 value)
        set1Value(SoMFVec4i32 self, int idx, int32_t x, int32_t y, int32_t z, int32_t w)
        set1Value(SoMFVec4i32 self, int idx, int32_t const [4] xyzw)
        """
        return _coin.SoMFVec4i32_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec4i32 self, SbVec4i32 value)
        setValue(SoMFVec4i32 self, int32_t x, int32_t y, int32_t z, int32_t w)
        setValue(SoMFVec4i32 self, int32_t const [4] 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__(SoMFVec4ui32 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(SoMFVec4ui32 self) -> SoType"""
        return _coin.SoMFVec4ui32_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec4ui32 self, SoField field)"""
        return _coin.SoMFVec4ui32_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec4ui32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec4ui32_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec4ui32 self, int const start) -> SbVec4ui32"""
        return _coin.SoMFVec4ui32_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec4ui32 self, SbVec4ui32 value, SbBool addifnotfound=0) -> int
        find(SoMFVec4ui32 self, SbVec4ui32 value) -> int
        """
        return _coin.SoMFVec4ui32_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec4ui32 self, SoMFVec4ui32 field) -> SbBool"""
        return _coin.SoMFVec4ui32___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec4ui32 self, SoMFVec4ui32 field) -> SbBool"""
        return _coin.SoMFVec4ui32___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec4ui32 self) -> SbVec4ui32"""
        return _coin.SoMFVec4ui32_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec4ui32 self)"""
        return _coin.SoMFVec4ui32_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec4ui32 self, int const num, SbVec4ui32 userdata)
        setValuesPointer(SoMFVec4ui32 self, int const num, SbVec4ui32 userdata)
        setValuesPointer(SoMFVec4ui32 self, int const num, uint32_t const * userdata)
        setValuesPointer(SoMFVec4ui32 self, int const 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(SoMFVec4ui32 self, int const start, int const num, SbVec4ui32 newvals)
        setValues(SoMFVec4ui32 self, int start, int num, uint32_t const [][4] xyzw)
        """
        return _coin.SoMFVec4ui32_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec4ui32 self, int const idx, SbVec4ui32 value)
        set1Value(SoMFVec4ui32 self, int idx, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        set1Value(SoMFVec4ui32 self, int idx, uint32_t const [4] xyzw)
        """
        return _coin.SoMFVec4ui32_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec4ui32 self, SbVec4ui32 value)
        setValue(SoMFVec4ui32 self, uint32_t x, uint32_t y, uint32_t z, uint32_t w)
        setValue(SoMFVec4ui32 self, uint32_t const [4] 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__(SoMFVec4d 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(SoMFVec4d self) -> SoType"""
        return _coin.SoMFVec4d_getTypeId(self)


    def copyFrom(self, field):
        """copyFrom(SoMFVec4d self, SoField field)"""
        return _coin.SoMFVec4d_copyFrom(self, field)


    def isSame(self, field):
        """isSame(SoMFVec4d self, SoField field) -> SbBool"""
        return _coin.SoMFVec4d_isSame(self, field)


    def getValues(self, start):
        """getValues(SoMFVec4d self, int const start) -> SbVec4d"""
        return _coin.SoMFVec4d_getValues(self, start)


    def find(self, value, addifnotfound=0):
        """
        find(SoMFVec4d self, SbVec4d value, SbBool addifnotfound=0) -> int
        find(SoMFVec4d self, SbVec4d value) -> int
        """
        return _coin.SoMFVec4d_find(self, value, addifnotfound)


    def __eq__(self, field):
        """__eq__(SoMFVec4d self, SoMFVec4d field) -> SbBool"""
        return _coin.SoMFVec4d___eq__(self, field)


    def __ne__(self, field):
        """__ne__(SoMFVec4d self, SoMFVec4d field) -> SbBool"""
        return _coin.SoMFVec4d___ne__(self, field)


    def startEditing(self):
        """startEditing(SoMFVec4d self) -> SbVec4d"""
        return _coin.SoMFVec4d_startEditing(self)


    def finishEditing(self):
        """finishEditing(SoMFVec4d self)"""
        return _coin.SoMFVec4d_finishEditing(self)


    def setValuesPointer(self, *args):
        """
        setValuesPointer(SoMFVec4d self, int const num, SbVec4d userdata)
        setValuesPointer(SoMFVec4d self, int const num, SbVec4d userdata)
        setValuesPointer(SoMFVec4d self, int const num, double const * userdata)
        setValuesPointer(SoMFVec4d self, int const num, double * userdata)
        """
        return _coin.SoMFVec4d_setValuesPointer(self, *args)


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

    initClass = staticmethod(initClass)

    def setValues(self, *args):
        """
        setValues(SoMFVec4d self, int const start, int const num, SbVec4d newvals)
        setValues(SoMFVec4d self, int start, int num, double const [][4] xyzw)
        """
        return _coin.SoMFVec4d_setValues(self, *args)


    def set1Value(self, *args):
        """
        set1Value(SoMFVec4d self, int const idx, SbVec4d value)
        set1Value(SoMFVec4d self, int idx, double x, double y, double z, double w)
        set1Value(SoMFVec4d self, int idx, double const [4] xyzw)
        """
        return _coin.SoMFVec4d_set1Value(self, *args)


    def setValue(self, *args):
        """
        setValue(SoMFVec4d self, SbVec4d value)
        setValue(SoMFVec4d self, double x, double y, double z, double w)
        setValue(SoMFVec4d self, double const [4] 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__(SbStringList self) -> SbStringList
        __init__(SbStringList self, int const sizehint) -> SbStringList
        """
        this = _coin.new_SbStringList(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def append(self, string):
        """append(SbStringList self, SbString string)"""
        return _coin.SbStringList_append(self, string)


    def find(self, string):
        """find(SbStringList self, SbString string) -> int"""
        return _coin.SbStringList_find(self, string)


    def insert(self, string, insertbefore):
        """insert(SbStringList self, SbString string, int insertbefore)"""
        return _coin.SbStringList_insert(self, string, insertbefore)


    def getArrayPtr(self):
        """getArrayPtr(SbStringList self) -> SbString const **"""
        return _coin.SbStringList_getArrayPtr(self)


    def __setitem__(self, i, value):
        """__setitem__(SbStringList self, int const i, SbString value)"""
        return _coin.SbStringList___setitem__(self, i, value)


    def __getitem__(self, i):
        """__getitem__(SbStringList self, int i) -> SbString"""
        return _coin.SbStringList___getitem__(self, i)


    def get(self, i):
        """get(SbStringList self, int const i) -> SbString"""
        return _coin.SbStringList_get(self, i)

    __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__(SbVec3fList 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, item):
        """append(SbVec3fList self, SbVec3f item)"""
        return _coin.SbVec3fList_append(self, item)


    def insert(self, item, insertbefore):
        """insert(SbVec3fList self, SbVec3f item, int const insertbefore)"""
        return _coin.SbVec3fList_insert(self, item, insertbefore)


    def __setitem__(self, i, value):
        """__setitem__(SbVec3fList self, int const i, SbVec3f value)"""
        return _coin.SbVec3fList___setitem__(self, i, value)


    def __getitem__(self, i):
        """__getitem__(SbVec3fList self, int i) -> SbVec3f"""
        return _coin.SbVec3fList___getitem__(self, i)


    def get(self, i):
        """get(SbVec3fList self, int const i) -> SbVec3f"""
        return _coin.SbVec3fList_get(self, i)

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(unlockstr):
        """SetUnlockString(char * unlockstr)"""
        return _coin.SoLockManager_SetUnlockString(unlockstr)

    SetUnlockString = staticmethod(SetUnlockString)

    def GetUnlockString():
        """GetUnlockString() -> char *"""
        return _coin.SoLockManager_GetUnlockString()

    GetUnlockString = staticmethod(GetUnlockString)

    def __init__(self):
        """__init__(SoLockManager 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(unlockstr):
    """SoLockManager_SetUnlockString(char * unlockstr)"""
    return _coin.SoLockManager_SetUnlockString(unlockstr)

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(SoTransform self) -> SoType"""
        return _coin.SoTransform_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTransform 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, frompoint, topoint):
        """pointAt(SoTransform self, SbVec3f frompoint, SbVec3f topoint)"""
        return _coin.SoTransform_pointAt(self, frompoint, topoint)


    def getScaleSpaceMatrix(self, mat, inv):
        """getScaleSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getScaleSpaceMatrix(self, mat, inv)


    def getRotationSpaceMatrix(self, mat, inv):
        """getRotationSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getRotationSpaceMatrix(self, mat, inv)


    def getTranslationSpaceMatrix(self, mat, inv):
        """getTranslationSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getTranslationSpaceMatrix(self, mat, inv)


    def multLeft(self, mat):
        """multLeft(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_multLeft(self, mat)


    def multRight(self, mat):
        """multRight(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_multRight(self, mat)


    def combineLeft(self, nodeonright):
        """combineLeft(SoTransform self, SoTransformation nodeonright)"""
        return _coin.SoTransform_combineLeft(self, nodeonright)


    def combineRight(self, nodeonleft):
        """combineRight(SoTransform self, SoTransformation nodeonleft)"""
        return _coin.SoTransform_combineRight(self, nodeonleft)


    def setMatrix(self, mat):
        """setMatrix(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_setMatrix(self, mat)


    def recenter(self, newcenter):
        """recenter(SoTransform self, SbVec3f newcenter)"""
        return _coin.SoTransform_recenter(self, newcenter)


    def doAction(self, action):
        """doAction(SoTransform self, SoAction action)"""
        return _coin.SoTransform_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTransform self, SoGLRenderAction action)"""
        return _coin.SoTransform_GLRender(self, action)


    def callback(self, action):
        """callback(SoTransform self, SoCallbackAction action)"""
        return _coin.SoTransform_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransform_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoTransform self, SoGetMatrixAction action)"""
        return _coin.SoTransform_getMatrix(self, action)


    def pick(self, action):
        """pick(SoTransform self, SoPickAction action)"""
        return _coin.SoTransform_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTransform_getPrimitiveCount(self, action)

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(SoTransformManip self) -> SoType"""
        return _coin.SoTransformManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTransformManip self) -> SoTransformManip"""
        this = _coin.new_SoTransformManip()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getDragger(self):
        """getDragger(SoTransformManip self) -> SoDragger"""
        return _coin.SoTransformManip_getDragger(self)


    def replaceNode(self, p):
        """replaceNode(SoTransformManip self, SoPath p) -> SbBool"""
        return _coin.SoTransformManip_replaceNode(self, p)


    def replaceManip(self, p, newone):
        """replaceManip(SoTransformManip self, SoPath p, SoTransform newone) -> SbBool"""
        return _coin.SoTransformManip_replaceManip(self, p, newone)


    def doAction(self, action):
        """doAction(SoTransformManip self, SoAction action)"""
        return _coin.SoTransformManip_doAction(self, action)


    def callback(self, action):
        """callback(SoTransformManip self, SoCallbackAction action)"""
        return _coin.SoTransformManip_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTransformManip self, SoGLRenderAction action)"""
        return _coin.SoTransformManip_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoTransformManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransformManip_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoTransformManip self, SoGetMatrixAction action)"""
        return _coin.SoTransformManip_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoTransformManip self, SoHandleEventAction action)"""
        return _coin.SoTransformManip_handleEvent(self, action)


    def pick(self, action):
        """pick(SoTransformManip self, SoPickAction action)"""
        return _coin.SoTransformManip_pick(self, action)


    def search(self, action):
        """search(SoTransformManip self, SoSearchAction action)"""
        return _coin.SoTransformManip_search(self, action)


    def getChildren(self):
        """getChildren(SoTransformManip 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(SoCenterballManip self) -> SoType"""
        return _coin.SoCenterballManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCenterballManip 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(SoClipPlane self) -> SoType"""
        return _coin.SoClipPlane_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoClipPlane 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, action):
        """doAction(SoClipPlane self, SoAction action)"""
        return _coin.SoClipPlane_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoClipPlane self, SoGLRenderAction action)"""
        return _coin.SoClipPlane_GLRender(self, action)


    def callback(self, action):
        """callback(SoClipPlane self, SoCallbackAction action)"""
        return _coin.SoClipPlane_callback(self, action)


    def pick(self, action):
        """pick(SoClipPlane self, SoPickAction action)"""
        return _coin.SoClipPlane_pick(self, action)

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(SoClipPlaneManip self) -> SoType"""
        return _coin.SoClipPlaneManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoClipPlaneManip self) -> SoClipPlaneManip"""
        this = _coin.new_SoClipPlaneManip()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getDragger(self):
        """getDragger(SoClipPlaneManip self) -> SoDragger"""
        return _coin.SoClipPlaneManip_getDragger(self)


    def setValue(self, box, planenormal, draggerscalefactor):
        """setValue(SoClipPlaneManip self, SbBox3f box, SbVec3f planenormal, float draggerscalefactor)"""
        return _coin.SoClipPlaneManip_setValue(self, box, planenormal, draggerscalefactor)


    def replaceNode(self, p):
        """replaceNode(SoClipPlaneManip self, SoPath p) -> SbBool"""
        return _coin.SoClipPlaneManip_replaceNode(self, p)


    def replaceManip(self, p, newone):
        """replaceManip(SoClipPlaneManip self, SoPath p, SoClipPlane newone) -> SbBool"""
        return _coin.SoClipPlaneManip_replaceManip(self, p, newone)


    def doAction(self, action):
        """doAction(SoClipPlaneManip self, SoAction action)"""
        return _coin.SoClipPlaneManip_doAction(self, action)


    def callback(self, action):
        """callback(SoClipPlaneManip self, SoCallbackAction action)"""
        return _coin.SoClipPlaneManip_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoClipPlaneManip self, SoGLRenderAction action)"""
        return _coin.SoClipPlaneManip_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoClipPlaneManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoClipPlaneManip_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoClipPlaneManip self, SoGetMatrixAction action)"""
        return _coin.SoClipPlaneManip_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoClipPlaneManip self, SoHandleEventAction action)"""
        return _coin.SoClipPlaneManip_handleEvent(self, action)


    def pick(self, action):
        """pick(SoClipPlaneManip self, SoPickAction action)"""
        return _coin.SoClipPlaneManip_pick(self, action)


    def search(self, action):
        """search(SoClipPlaneManip self, SoSearchAction action)"""
        return _coin.SoClipPlaneManip_search(self, action)


    def getChildren(self):
        """getChildren(SoClipPlaneManip 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(SoLight 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, action):
        """callback(SoLight self, SoCallbackAction action)"""
        return _coin.SoLight_callback(self, action)

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(SoDirectionalLight self) -> SoType"""
        return _coin.SoDirectionalLight_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoDirectionalLight 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, action):
        """GLRender(SoDirectionalLight self, SoGLRenderAction action)"""
        return _coin.SoDirectionalLight_GLRender(self, action)

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(SoDirectionalLightManip self) -> SoType"""
        return _coin.SoDirectionalLightManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoDirectionalLightManip self) -> SoDirectionalLightManip"""
        this = _coin.new_SoDirectionalLightManip()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getDragger(self):
        """getDragger(SoDirectionalLightManip self) -> SoDragger"""
        return _coin.SoDirectionalLightManip_getDragger(self)


    def replaceNode(self, path):
        """replaceNode(SoDirectionalLightManip self, SoPath path) -> SbBool"""
        return _coin.SoDirectionalLightManip_replaceNode(self, path)


    def replaceManip(self, path, newone):
        """replaceManip(SoDirectionalLightManip self, SoPath path, SoDirectionalLight newone) -> SbBool"""
        return _coin.SoDirectionalLightManip_replaceManip(self, path, newone)


    def doAction(self, action):
        """doAction(SoDirectionalLightManip self, SoAction action)"""
        return _coin.SoDirectionalLightManip_doAction(self, action)


    def callback(self, action):
        """callback(SoDirectionalLightManip self, SoCallbackAction action)"""
        return _coin.SoDirectionalLightManip_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoDirectionalLightManip self, SoGLRenderAction action)"""
        return _coin.SoDirectionalLightManip_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoDirectionalLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoDirectionalLightManip_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoDirectionalLightManip self, SoGetMatrixAction action)"""
        return _coin.SoDirectionalLightManip_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoDirectionalLightManip self, SoHandleEventAction action)"""
        return _coin.SoDirectionalLightManip_handleEvent(self, action)


    def pick(self, action):
        """pick(SoDirectionalLightManip self, SoPickAction action)"""
        return _coin.SoDirectionalLightManip_pick(self, action)


    def search(self, action):
        """search(SoDirectionalLightManip self, SoSearchAction action)"""
        return _coin.SoDirectionalLightManip_search(self, action)


    def getChildren(self):
        """getChildren(SoDirectionalLightManip 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(SoHandleBoxManip self) -> SoType"""
        return _coin.SoHandleBoxManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoHandleBoxManip 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(SoJackManip self) -> SoType"""
        return _coin.SoJackManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoJackManip 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(SoPointLight self) -> SoType"""
        return _coin.SoPointLight_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPointLight 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, action):
        """GLRender(SoPointLight self, SoGLRenderAction action)"""
        return _coin.SoPointLight_GLRender(self, action)

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(SoPointLightManip self) -> SoType"""
        return _coin.SoPointLightManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPointLightManip self) -> SoPointLightManip"""
        this = _coin.new_SoPointLightManip()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getDragger(self):
        """getDragger(SoPointLightManip self) -> SoDragger"""
        return _coin.SoPointLightManip_getDragger(self)


    def replaceNode(self, path):
        """replaceNode(SoPointLightManip self, SoPath path) -> SbBool"""
        return _coin.SoPointLightManip_replaceNode(self, path)


    def replaceManip(self, path, newone):
        """replaceManip(SoPointLightManip self, SoPath path, SoPointLight newone) -> SbBool"""
        return _coin.SoPointLightManip_replaceManip(self, path, newone)


    def doAction(self, action):
        """doAction(SoPointLightManip self, SoAction action)"""
        return _coin.SoPointLightManip_doAction(self, action)


    def callback(self, action):
        """callback(SoPointLightManip self, SoCallbackAction action)"""
        return _coin.SoPointLightManip_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoPointLightManip self, SoGLRenderAction action)"""
        return _coin.SoPointLightManip_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoPointLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoPointLightManip_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoPointLightManip self, SoGetMatrixAction action)"""
        return _coin.SoPointLightManip_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoPointLightManip self, SoHandleEventAction action)"""
        return _coin.SoPointLightManip_handleEvent(self, action)


    def pick(self, action):
        """pick(SoPointLightManip self, SoPickAction action)"""
        return _coin.SoPointLightManip_pick(self, action)


    def search(self, action):
        """search(SoPointLightManip self, SoSearchAction action)"""
        return _coin.SoPointLightManip_search(self, action)


    def getChildren(self):
        """getChildren(SoPointLightManip 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(SoSpotLight self) -> SoType"""
        return _coin.SoSpotLight_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSpotLight 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, action):
        """GLRender(SoSpotLight self, SoGLRenderAction action)"""
        return _coin.SoSpotLight_GLRender(self, action)

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(SoSpotLightManip self) -> SoType"""
        return _coin.SoSpotLightManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSpotLightManip self) -> SoSpotLightManip"""
        this = _coin.new_SoSpotLightManip()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getDragger(self):
        """getDragger(SoSpotLightManip self) -> SoDragger"""
        return _coin.SoSpotLightManip_getDragger(self)


    def replaceNode(self, p):
        """replaceNode(SoSpotLightManip self, SoPath p) -> SbBool"""
        return _coin.SoSpotLightManip_replaceNode(self, p)


    def replaceManip(self, p, newone):
        """replaceManip(SoSpotLightManip self, SoPath p, SoSpotLight newone) -> SbBool"""
        return _coin.SoSpotLightManip_replaceManip(self, p, newone)


    def doAction(self, action):
        """doAction(SoSpotLightManip self, SoAction action)"""
        return _coin.SoSpotLightManip_doAction(self, action)


    def callback(self, action):
        """callback(SoSpotLightManip self, SoCallbackAction action)"""
        return _coin.SoSpotLightManip_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoSpotLightManip self, SoGLRenderAction action)"""
        return _coin.SoSpotLightManip_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoSpotLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoSpotLightManip_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoSpotLightManip self, SoGetMatrixAction action)"""
        return _coin.SoSpotLightManip_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoSpotLightManip self, SoHandleEventAction action)"""
        return _coin.SoSpotLightManip_handleEvent(self, action)


    def pick(self, action):
        """pick(SoSpotLightManip self, SoPickAction action)"""
        return _coin.SoSpotLightManip_pick(self, action)


    def search(self, action):
        """search(SoSpotLightManip self, SoSearchAction action)"""
        return _coin.SoSpotLightManip_search(self, action)


    def getChildren(self):
        """getChildren(SoSpotLightManip 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(SoTabBoxManip self) -> SoType"""
        return _coin.SoTabBoxManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTabBoxManip 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(SoTrackballManip self) -> SoType"""
        return _coin.SoTrackballManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTrackballManip 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(SoTransformBoxManip self) -> SoType"""
        return _coin.SoTransformBoxManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTransformBoxManip 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(SoTransformerManip self) -> SoType"""
        return _coin.SoTransformerManip_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTransformerManip self) -> SoTransformerManip"""
        this = _coin.new_SoTransformerManip()
        try:
            self.this.append(this)
        except:
            self.this = this

    def isLocateHighlighting(self):
        """isLocateHighlighting(SoTransformerManip self) -> SbBool"""
        return _coin.SoTransformerManip_isLocateHighlighting(self)


    def setLocateHighlighting(self, onoff):
        """setLocateHighlighting(SoTransformerManip self, SbBool onoff)"""
        return _coin.SoTransformerManip_setLocateHighlighting(self, onoff)


    def unsquishKnobs(self):
        """unsquishKnobs(SoTransformerManip 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, devicetype, devicename):
        """init(SoAudioDevice self, SbString devicetype, SbString devicename) -> SbBool"""
        return _coin.SoAudioDevice_init(self, devicetype, devicename)


    def enable(self):
        """enable(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_enable(self)


    def disable(self):
        """disable(SoAudioDevice self)"""
        return _coin.SoAudioDevice_disable(self)


    def isEnabled(self):
        """isEnabled(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_isEnabled(self)


    def haveSound(self):
        """haveSound(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_haveSound(self)


    def setGain(self, gain):
        """setGain(SoAudioDevice self, float gain)"""
        return _coin.SoAudioDevice_setGain(self, gain)


    def mute(self, mute=1):
        """
        mute(SoAudioDevice self, SbBool mute=1)
        mute(SoAudioDevice 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__(SoByteStream 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(SoByteStream self, SoNode node, SbBool binary=1)
        convert(SoByteStream self, SoNode node)
        convert(SoByteStream self, SoPath path, SbBool binary=1)
        convert(SoByteStream self, SoPath path)
        convert(SoByteStream self, SoPathList pl, SbBool binary=1)
        convert(SoByteStream self, SoPathList pl)
        """
        return _coin.SoByteStream_convert(self, *args)


    def getData(self):
        """getData(SoByteStream self) -> void *"""
        return _coin.SoByteStream_getData(self)


    def getNumBytes(self):
        """getNumBytes(SoByteStream 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, d, len):
        """copy(SoByteStream self, void * d, size_t len)"""
        return _coin.SoByteStream_copy(self, d, len)


    def isRawData(self):
        """isRawData(SoByteStream 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(contextid):
        """destructingContext(uint32_t contextid)"""
        return _coin.SoContextHandler_destructingContext(contextid)

    destructingContext = staticmethod(destructingContext)

    def addContextDestructionCallback(func, closure):
        """addContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
        return _coin.SoContextHandler_addContextDestructionCallback(func, closure)

    addContextDestructionCallback = staticmethod(addContextDestructionCallback)

    def removeContextDestructionCallback(func, closure):
        """removeContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
        return _coin.SoContextHandler_removeContextDestructionCallback(func, closure)

    removeContextDestructionCallback = staticmethod(removeContextDestructionCallback)

    def __init__(self):
        """__init__(SoContextHandler 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(contextid):
    """SoContextHandler_destructingContext(uint32_t contextid)"""
    return _coin.SoContextHandler_destructingContext(contextid)

def SoContextHandler_addContextDestructionCallback(func, closure):
    """SoContextHandler_addContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
    return _coin.SoContextHandler_addContextDestructionCallback(func, closure)

def SoContextHandler_removeContextDestructionCallback(func, closure):
    """SoContextHandler_removeContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
    return _coin.SoContextHandler_removeContextDestructionCallback(func, closure)

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__(SoGLImage self) -> SoGLImage"""
        this = _coin.new_SoGLImage()
        try:
            self.this.append(this)
        except:
            self.this = this

    def unref(self, state=None):
        """
        unref(SoGLImage self, SoState state=None)
        unref(SoGLImage self)
        """
        return _coin.SoGLImage_unref(self, state)


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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def isOfType(self, type):
        """isOfType(SoGLImage self, SoType type) -> SbBool"""
        return _coin.SoGLImage_isOfType(self, type)

    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(SoGLImage self, SoGLDisplayList dl, SoState state, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5)
        setGLDisplayList(SoGLImage self, SoGLDisplayList dl, SoState state, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt)
        setGLDisplayList(SoGLImage self, SoGLDisplayList dl, SoState state, SoGLImage::Wrap const wraps)
        setGLDisplayList(SoGLImage self, SoGLDisplayList dl, SoState state)
        """
        return _coin.SoGLImage_setGLDisplayList(self, *args)


    def setPBuffer(self, *args):
        """
        setPBuffer(SoGLImage self, SoState state, void * context, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5)
        setPBuffer(SoGLImage self, SoState state, void * context, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt)
        setPBuffer(SoGLImage self, SoState state, void * context, SoGLImage::Wrap const wraps)
        setPBuffer(SoGLImage self, SoState state, void * context)
        """
        return _coin.SoGLImage_setPBuffer(self, *args)


    def setData(self, *args):
        """
        setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5, int const border=0)
        setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5)
        setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt)
        setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents, SoGLImage::Wrap const wraps)
        setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents)
        setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0)
        setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5)
        setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr)
        setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt)
        setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents, SoGLImage::Wrap const wraps)
        setData(SoGLImage self, unsigned char const * bytes, SbVec3s size, int const numcomponents)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5, int const border=0)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps)
        setData(SoGLImage self, SbImage image)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const 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, flags):
        """setFlags(SoGLImage self, uint32_t const flags)"""
        return _coin.SoGLImage_setFlags(self, flags)


    def getFlags(self):
        """getFlags(SoGLImage self) -> uint32_t"""
        return _coin.SoGLImage_getFlags(self)


    def getImage(self):
        """getImage(SoGLImage self) -> SbImage"""
        return _coin.SoGLImage_getImage(self)


    def getGLDisplayList(self, state):
        """getGLDisplayList(SoGLImage self, SoState state) -> SoGLDisplayList"""
        return _coin.SoGLImage_getGLDisplayList(self, state)


    def hasTransparency(self):
        """hasTransparency(SoGLImage self) -> SbBool"""
        return _coin.SoGLImage_hasTransparency(self)


    def useAlphaTest(self):
        """useAlphaTest(SoGLImage self) -> SbBool"""
        return _coin.SoGLImage_useAlphaTest(self)


    def getWrapS(self):
        """getWrapS(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapS(self)


    def getWrapT(self):
        """getWrapT(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapT(self)


    def getWrapR(self):
        """getWrapR(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapR(self)


    def getQuality(self):
        """getQuality(SoGLImage self) -> float"""
        return _coin.SoGLImage_getQuality(self)


    def getGLImageId(self):
        """getGLImageId(SoGLImage self) -> uint32_t"""
        return _coin.SoGLImage_getGLImageId(self)


    def beginFrame(state):
        """beginFrame(SoState state)"""
        return _coin.SoGLImage_beginFrame(state)

    beginFrame = staticmethod(beginFrame)

    def tagImage(state, image):
        """tagImage(SoState state, SoGLImage image)"""
        return _coin.SoGLImage_tagImage(state, image)

    tagImage = staticmethod(tagImage)

    def endFrame(state):
        """endFrame(SoState state)"""
        return _coin.SoGLImage_endFrame(state)

    endFrame = staticmethod(endFrame)

    def setDisplayListMaxAge(maxage):
        """setDisplayListMaxAge(uint32_t const maxage)"""
        return _coin.SoGLImage_setDisplayListMaxAge(maxage)

    setDisplayListMaxAge = staticmethod(setDisplayListMaxAge)

    def freeAllImages(state=None):
        """
        freeAllImages(SoState state=None)
        freeAllImages()
        """
        return _coin.SoGLImage_freeAllImages(state)

    freeAllImages = staticmethod(freeAllImages)

    def setEndFrameCallback(self, cb, closure):
        """setEndFrameCallback(SoGLImage self, void (*)(void *) cb, void * closure)"""
        return _coin.SoGLImage_setEndFrameCallback(self, cb, closure)


    def getNumFramesSinceUsed(self):
        """getNumFramesSinceUsed(SoGLImage self) -> int"""
        return _coin.SoGLImage_getNumFramesSinceUsed(self)


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

    initClass = staticmethod(initClass)

    def setResizeCallback(f, closure):
        """setResizeCallback(SoGLImage::SoGLImageResizeCB * f, void * closure)"""
        return _coin.SoGLImage_setResizeCallback(f, closure)

    setResizeCallback = staticmethod(setResizeCallback)
SoGLImage_swigregister = _coin.SoGLImage_swigregister
SoGLImage_swigregister(SoGLImage)

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

def SoGLImage_beginFrame(state):
    """SoGLImage_beginFrame(SoState state)"""
    return _coin.SoGLImage_beginFrame(state)

def SoGLImage_tagImage(state, image):
    """SoGLImage_tagImage(SoState state, SoGLImage image)"""
    return _coin.SoGLImage_tagImage(state, image)

def SoGLImage_endFrame(state):
    """SoGLImage_endFrame(SoState state)"""
    return _coin.SoGLImage_endFrame(state)

def SoGLImage_setDisplayListMaxAge(maxage):
    """SoGLImage_setDisplayListMaxAge(uint32_t const maxage)"""
    return _coin.SoGLImage_setDisplayListMaxAge(maxage)

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(f, closure):
    """SoGLImage_setResizeCallback(SoGLImage::SoGLImageResizeCB * f, void * closure)"""
    return _coin.SoGLImage_setResizeCallback(f, closure)

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__(SoGLBigImage self) -> SoGLBigImage"""
        this = _coin.new_SoGLBigImage()
        try:
            self.this.append(this)
        except:
            self.this = this

    def unref(self, state=None):
        """
        unref(SoGLBigImage self, SoState state=None)
        unref(SoGLBigImage self)
        """
        return _coin.SoGLBigImage_unref(self, state)


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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def setData(self, *args):
        """
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5, int const border=0)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, float const quality=0.5)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps)
        setData(SoGLBigImage self, SbImage image)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5, int const border=0)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr, float const quality=0.5)
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps, SoGLImage::Wrap const wrapt, SoGLImage::Wrap const wrapr)
        """
        return _coin.SoGLBigImage_setData(self, *args)


    def initSubImages(self, subimagesize):
        """initSubImages(SoGLBigImage self, SbVec2s subimagesize) -> int"""
        return _coin.SoGLBigImage_initSubImages(self, subimagesize)


    def handleSubImage(self, idx, start, end, tcmul):
        """handleSubImage(SoGLBigImage self, int const idx, SbVec2f start, SbVec2f end, SbVec2f tcmul)"""
        return _coin.SoGLBigImage_handleSubImage(self, idx, start, end, tcmul)


    def applySubImage(self, state, idx, quality, projsize):
        """applySubImage(SoGLBigImage self, SoState state, int const idx, float const quality, SbVec2s projsize)"""
        return _coin.SoGLBigImage_applySubImage(self, state, idx, quality, projsize)


    def exceededChangeLimit(self):
        """exceededChangeLimit(SoGLBigImage self) -> SbBool"""
        return _coin.SoGLBigImage_exceededChangeLimit(self)


    def setChangeLimit(limit):
        """setChangeLimit(int const limit) -> int"""
        return _coin.SoGLBigImage_setChangeLimit(limit)

    setChangeLimit = staticmethod(setChangeLimit)

    def getGLDisplayList(self, state):
        """getGLDisplayList(SoGLBigImage self, SoState state) -> SoGLDisplayList"""
        return _coin.SoGLBigImage_getGLDisplayList(self, state)


    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(limit):
    """SoGLBigImage_setChangeLimit(int const limit) -> int"""
    return _coin.SoGLBigImage_setChangeLimit(limit)

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(SoGlyph self)"""
        return _coin.SoGlyph_unref(self)


    def getCoords(self):
        """getCoords(SoGlyph self) -> SbVec2f"""
        return _coin.SoGlyph_getCoords(self)


    def getFaceIndices(self):
        """getFaceIndices(SoGlyph self) -> int const *"""
        return _coin.SoGlyph_getFaceIndices(self)


    def getEdgeIndices(self):
        """getEdgeIndices(SoGlyph self) -> int const *"""
        return _coin.SoGlyph_getEdgeIndices(self)


    def getNextCWEdge(self, edgeidx):
        """getNextCWEdge(SoGlyph self, int const edgeidx) -> int const *"""
        return _coin.SoGlyph_getNextCWEdge(self, edgeidx)


    def getNextCCWEdge(self, edgeidx):
        """getNextCCWEdge(SoGlyph self, int const edgeidx) -> int const *"""
        return _coin.SoGlyph_getNextCCWEdge(self, edgeidx)


    def getWidth(self):
        """getWidth(SoGlyph self) -> float"""
        return _coin.SoGlyph_getWidth(self)


    def getBoundingBox(self):
        """getBoundingBox(SoGlyph self) -> SbBox2f"""
        return _coin.SoGlyph_getBoundingBox(self)


    def getGlyph(*args):
        """
        getGlyph(char const character, SbName font) -> SoGlyph
        getGlyph(SoState state, unsigned int const character, SbVec2s size, float const angle) -> SoGlyph
        """
        return _coin.SoGlyph_getGlyph(*args)

    getGlyph = staticmethod(getGlyph)

    def getAdvance(self):
        """getAdvance(SoGlyph self) -> SbVec2s"""
        return _coin.SoGlyph_getAdvance(self)


    def getKerning(self, rightglyph):
        """getKerning(SoGlyph self, SoGlyph rightglyph) -> SbVec2s"""
        return _coin.SoGlyph_getKerning(self, rightglyph)


    def getBitmap(self, size, pos, antialiased):
        """getBitmap(SoGlyph self, SbVec2s size, SbVec2s pos, SbBool const antialiased) -> unsigned char *"""
        return _coin.SoGlyph_getBitmap(self, size, pos, antialiased)

SoGlyph_swigregister = _coin.SoGlyph_swigregister
SoGlyph_swigregister(SoGlyph)

def SoGlyph_getGlyph(*args):
    """
    getGlyph(char const character, SbName font) -> SoGlyph
    SoGlyph_getGlyph(SoState state, unsigned int const character, SbVec2s size, float const 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__(SoProto self, SbBool const externproto=0) -> SoProto
        __init__(SoProto self) -> SoProto
        """
        this = _coin.new_SoProto(externproto)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setFetchExternProtoCallback(cb, closure):
        """setFetchExternProtoCallback(SoFetchExternProtoCB * cb, void * closure)"""
        return _coin.SoProto_setFetchExternProtoCallback(cb, closure)

    setFetchExternProtoCallback = staticmethod(setFetchExternProtoCallback)

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


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

    getClassTypeId = staticmethod(getClassTypeId)

    def findProto(name):
        """findProto(SbName name) -> SoProto"""
        return _coin.SoProto_findProto(name)

    findProto = staticmethod(findProto)

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

    initClass = staticmethod(initClass)

    def createProtoInstance(self):
        """createProtoInstance(SoProto self) -> SoProtoInstance"""
        return _coin.SoProto_createProtoInstance(self)


    def addISReference(self, container, fieldname, interfacename):
        """addISReference(SoProto self, SoNode container, SbName fieldname, SbName interfacename)"""
        return _coin.SoProto_addISReference(self, container, fieldname, interfacename)


    def findISReference(self, container, fieldname):
        """findISReference(SoProto self, SoFieldContainer container, SbName fieldname) -> SbName"""
        return _coin.SoProto_findISReference(self, container, fieldname)


    def addReference(self, name, base):
        """addReference(SoProto self, SbName name, SoBase base)"""
        return _coin.SoProto_addReference(self, name, base)


    def removeReference(self, name):
        """removeReference(SoProto self, SbName name)"""
        return _coin.SoProto_removeReference(self, name)


    def findReference(self, name):
        """findReference(SoProto self, SbName name) -> SoBase"""
        return _coin.SoProto_findReference(self, name)


    def addRoute(self, fromnode, fromfield, tonode, tofield):
        """addRoute(SoProto self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"""
        return _coin.SoProto_addRoute(self, fromnode, fromfield, tonode, tofield)


    def getProtoName(self):
        """getProtoName(SoProto self) -> SbName"""
        return _coin.SoProto_getProtoName(self)


    def readInstance(self, input, flags):
        """readInstance(SoProto self, SoInput input, unsigned short flags) -> SbBool"""
        return _coin.SoProto_readInstance(self, input, flags)


    def write(self, action):
        """write(SoProto self, SoWriteAction action)"""
        return _coin.SoProto_write(self, action)

SoProto_swigregister = _coin.SoProto_swigregister
SoProto_swigregister(SoProto)

def SoProto_setFetchExternProtoCallback(cb, closure):
    """SoProto_setFetchExternProtoCallback(SoFetchExternProtoCB * cb, void * closure)"""
    return _coin.SoProto_setFetchExternProtoCallback(cb, closure)

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

def SoProto_findProto(name):
    """SoProto_findProto(SbName name) -> SoProto"""
    return _coin.SoProto_findProto(name)

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(SoProtoInstance self) -> SoType"""
        return _coin.SoProtoInstance_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self, proto, deffielddata):
        """__init__(SoProtoInstance self, SoProto proto, SoFieldData deffielddata) -> SoProtoInstance"""
        this = _coin.new_SoProtoInstance(proto, deffielddata)
        try:
            self.this.append(this)
        except:
            self.this = this

    def findProtoInstance(rootnode):
        """findProtoInstance(SoNode rootnode) -> SoProtoInstance"""
        return _coin.SoProtoInstance_findProtoInstance(rootnode)

    findProtoInstance = staticmethod(findProtoInstance)

    def setRootNode(self, root):
        """setRootNode(SoProtoInstance self, SoNode root)"""
        return _coin.SoProtoInstance_setRootNode(self, root)


    def getRootNode(self):
        """getRootNode(SoProtoInstance self) -> SoNode"""
        return _coin.SoProtoInstance_getRootNode(self)


    def getProtoDefinition(self):
        """getProtoDefinition(SoProtoInstance self) -> SoProto"""
        return _coin.SoProtoInstance_getProtoDefinition(self)


    def getProtoName(self):
        """getProtoName(SoProtoInstance self) -> SbName"""
        return _coin.SoProtoInstance_getProtoName(self)


    def write(self, action):
        """write(SoProtoInstance self, SoWriteAction action)"""
        return _coin.SoProtoInstance_write(self, action)

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(rootnode):
    """SoProtoInstance_findProtoInstance(SoNode rootnode) -> SoProtoInstance"""
    return _coin.SoProtoInstance_findProtoInstance(rootnode)

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, root):
        """__init__(SoTranReceiver self, SoGroup root) -> SoTranReceiver"""
        this = _coin.new_SoTranReceiver(root)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoTranReceiver
    __del__ = lambda self: None

    def interpret(self, input):
        """interpret(SoTranReceiver self, SoInput input) -> SbBool"""
        return _coin.SoTranReceiver_interpret(self, input)

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, output):
        """__init__(SoTranSender self, SoOutput output) -> SoTranSender"""
        this = _coin.new_SoTranSender(output)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SoTranSender
    __del__ = lambda self: None

    def getOutput(self):
        """getOutput(SoTranSender self) -> SoOutput"""
        return _coin.SoTranSender_getOutput(self)


    def insert(self, *args):
        """
        insert(SoTranSender self, SoNode node)
        insert(SoTranSender self, SoNode node, SoNode parent, int n)
        """
        return _coin.SoTranSender_insert(self, *args)


    def remove(self, parent, n):
        """remove(SoTranSender self, SoNode parent, int n)"""
        return _coin.SoTranSender_remove(self, parent, n)


    def replace(self, parent, n, newnode):
        """replace(SoTranSender self, SoNode parent, int n, SoNode newnode)"""
        return _coin.SoTranSender_replace(self, parent, n, newnode)


    def modify(self, node):
        """modify(SoTranSender self, SoNode node)"""
        return _coin.SoTranSender_modify(self, node)


    def prepareToSend(self):
        """prepareToSend(SoTranSender 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(SoAppearanceKit self) -> SoType"""
        return _coin.SoAppearanceKit_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoAppearanceKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoAppearanceKit self) -> SoNodekitCatalog"""
        return _coin.SoAppearanceKit_getNodekitCatalog(self)


    def __init__(self):
        """__init__(SoAppearanceKit 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(SoCameraKit self) -> SoType"""
        return _coin.SoCameraKit_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoCameraKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoCameraKit self) -> SoNodekitCatalog"""
        return _coin.SoCameraKit_getNodekitCatalog(self)


    def __init__(self):
        """__init__(SoCameraKit 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(SoLightKit self) -> SoType"""
        return _coin.SoLightKit_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoLightKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoLightKit self) -> SoNodekitCatalog"""
        return _coin.SoLightKit_getNodekitCatalog(self)


    def __init__(self):
        """__init__(SoLightKit 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__(SoNodeKit 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(SoSceneKit self) -> SoType"""
        return _coin.SoSceneKit_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSceneKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoSceneKit self) -> SoNodekitCatalog"""
        return _coin.SoSceneKit_getNodekitCatalog(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSceneKit self) -> SoSceneKit"""
        this = _coin.new_SoSceneKit()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getCameraNumber(self):
        """getCameraNumber(SoSceneKit self) -> int"""
        return _coin.SoSceneKit_getCameraNumber(self)


    def setCameraNumber(self, camNum):
        """setCameraNumber(SoSceneKit self, int camNum)"""
        return _coin.SoSceneKit_setCameraNumber(self, camNum)


    def affectsState(self):
        """affectsState(SoSceneKit 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(SoSeparatorKit self) -> SoType"""
        return _coin.SoSeparatorKit_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSeparatorKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoSeparatorKit self) -> SoNodekitCatalog"""
        return _coin.SoSeparatorKit_getNodekitCatalog(self)


    def __init__(self):
        """__init__(SoSeparatorKit 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(SoShapeKit self) -> SoType"""
        return _coin.SoShapeKit_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoShapeKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoShapeKit self) -> SoNodekitCatalog"""
        return _coin.SoShapeKit_getNodekitCatalog(self)


    def __init__(self):
        """__init__(SoShapeKit 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(SoWrapperKit self) -> SoType"""
        return _coin.SoWrapperKit_getTypeId(self)


    def getClassNodekitCatalog():
        """getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoWrapperKit_getClassNodekitCatalog()

    getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)

    def getNodekitCatalog(self):
        """getNodekitCatalog(SoWrapperKit self) -> SoNodekitCatalog"""
        return _coin.SoWrapperKit_getNodekitCatalog(self)


    def __init__(self):
        """__init__(SoWrapperKit 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(SoGroup self) -> SoType"""
        return _coin.SoGroup_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoGroup self) -> SoGroup
        __init__(SoGroup self, int nchildren) -> SoGroup
        """
        this = _coin.new_SoGroup(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def addChild(self, node):
        """addChild(SoGroup self, SoNode node)"""
        return _coin.SoGroup_addChild(self, node)


    def insertChild(self, child, newchildindex):
        """insertChild(SoGroup self, SoNode child, int newchildindex)"""
        return _coin.SoGroup_insertChild(self, child, newchildindex)


    def getChild(self, index):
        """getChild(SoGroup self, int index) -> SoNode"""
        return _coin.SoGroup_getChild(self, index)


    def findChild(self, node):
        """findChild(SoGroup self, SoNode node) -> int"""
        return _coin.SoGroup_findChild(self, node)


    def getNumChildren(self):
        """getNumChildren(SoGroup self) -> int"""
        return _coin.SoGroup_getNumChildren(self)


    def removeChild(self, *args):
        """
        removeChild(SoGroup self, int childindex)
        removeChild(SoGroup self, SoNode child)
        """
        return _coin.SoGroup_removeChild(self, *args)


    def removeAllChildren(self):
        """removeAllChildren(SoGroup self)"""
        return _coin.SoGroup_removeAllChildren(self)


    def replaceChild(self, *args):
        """
        replaceChild(SoGroup self, int index, SoNode newchild)
        replaceChild(SoGroup self, SoNode oldchild, SoNode newchild)
        """
        return _coin.SoGroup_replaceChild(self, *args)


    def doAction(self, action):
        """doAction(SoGroup self, SoAction action)"""
        return _coin.SoGroup_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoGroup self, SoGLRenderAction action)"""
        return _coin.SoGroup_GLRender(self, action)


    def callback(self, action):
        """callback(SoGroup self, SoCallbackAction action)"""
        return _coin.SoGroup_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoGroup self, SoGetBoundingBoxAction action)"""
        return _coin.SoGroup_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoGroup self, SoGetMatrixAction action)"""
        return _coin.SoGroup_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoGroup self, SoHandleEventAction action)"""
        return _coin.SoGroup_handleEvent(self, action)


    def pick(self, action):
        """pick(SoGroup self, SoPickAction action)"""
        return _coin.SoGroup_pick(self, action)


    def search(self, action):
        """search(SoGroup self, SoSearchAction action)"""
        return _coin.SoGroup_search(self, action)


    def write(self, action):
        """write(SoGroup self, SoWriteAction action)"""
        return _coin.SoGroup_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoGroup self, SoGetPrimitiveCountAction action)"""
        return _coin.SoGroup_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoGroup self, SoAudioRenderAction action)"""
        return _coin.SoGroup_audioRender(self, action)


    def getChildren(self):
        """getChildren(SoGroup 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):
        """__len__(SoGroup self) -> int"""
        return _coin.SoGroup___len__(self)


    def __contains__(self, node):
        """__contains__(SoGroup self, SoNode node) -> int"""
        return _coin.SoGroup___contains__(self, node)


    def __getitem__(self, index):
        """__getitem__(SoGroup self, int index) -> SoNode"""
        return _coin.SoGroup___getitem__(self, index)

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(SoSeparator self) -> SoType"""
        return _coin.SoSeparator_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoSeparator self) -> SoSeparator
        __init__(SoSeparator self, int const 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, action):
        """doAction(SoSeparator self, SoAction action)"""
        return _coin.SoSeparator_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRender(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderBelowPath(self, action)


    def GLRenderInPath(self, action):
        """GLRenderInPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderInPath(self, action)


    def GLRenderOffPath(self, action):
        """GLRenderOffPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderOffPath(self, action)


    def callback(self, action):
        """callback(SoSeparator self, SoCallbackAction action)"""
        return _coin.SoSeparator_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoSeparator self, SoGetBoundingBoxAction action)"""
        return _coin.SoSeparator_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoSeparator self, SoGetMatrixAction action)"""
        return _coin.SoSeparator_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoSeparator self, SoHandleEventAction action)"""
        return _coin.SoSeparator_handleEvent(self, action)


    def rayPick(self, action):
        """rayPick(SoSeparator self, SoRayPickAction action)"""
        return _coin.SoSeparator_rayPick(self, action)


    def search(self, action):
        """search(SoSeparator self, SoSearchAction action)"""
        return _coin.SoSeparator_search(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoSeparator self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSeparator_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoSeparator self, SoAudioRenderAction action)"""
        return _coin.SoSeparator_audioRender(self, action)


    def notify(self, nl):
        """notify(SoSeparator self, SoNotList nl)"""
        return _coin.SoSeparator_notify(self, nl)


    def setNumRenderCaches(howmany):
        """setNumRenderCaches(int const howmany)"""
        return _coin.SoSeparator_setNumRenderCaches(howmany)

    setNumRenderCaches = staticmethod(setNumRenderCaches)

    def getNumRenderCaches():
        """getNumRenderCaches() -> int"""
        return _coin.SoSeparator_getNumRenderCaches()

    getNumRenderCaches = staticmethod(getNumRenderCaches)

    def affectsState(self):
        """affectsState(SoSeparator 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(howmany):
    """SoSeparator_setNumRenderCaches(int const howmany)"""
    return _coin.SoSeparator_setNumRenderCaches(howmany)

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(SoAnnotation self) -> SoType"""
        return _coin.SoAnnotation_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoAnnotation self) -> SoAnnotation"""
        this = _coin.new_SoAnnotation()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GLRender(self, action):
        """GLRender(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRender(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderBelowPath(self, action)


    def GLRenderInPath(self, action):
        """GLRenderInPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderInPath(self, action)


    def GLRenderOffPath(self, action):
        """GLRenderOffPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderOffPath(self, action)

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(SoAntiSquish self) -> SoType"""
        return _coin.SoAntiSquish_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoAntiSquish 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(SoAntiSquish self)"""
        return _coin.SoAntiSquish_recalc(self)


    def doAction(self, action):
        """doAction(SoAntiSquish self, SoAction action)"""
        return _coin.SoAntiSquish_doAction(self, action)

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(SoArray self) -> SoType"""
        return _coin.SoArray_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoArray 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(SoArray self) -> SbBool"""
        return _coin.SoArray_affectsState(self)


    def doAction(self, action):
        """doAction(SoArray self, SoAction action)"""
        return _coin.SoArray_doAction(self, action)


    def callback(self, action):
        """callback(SoArray self, SoCallbackAction action)"""
        return _coin.SoArray_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoArray self, SoGLRenderAction action)"""
        return _coin.SoArray_GLRender(self, action)


    def pick(self, action):
        """pick(SoArray self, SoPickAction action)"""
        return _coin.SoArray_pick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoArray self, SoGetBoundingBoxAction action)"""
        return _coin.SoArray_getBoundingBox(self, action)


    def handleEvent(self, action):
        """handleEvent(SoArray self, SoHandleEventAction action)"""
        return _coin.SoArray_handleEvent(self, action)


    def getMatrix(self, action):
        """getMatrix(SoArray self, SoGetMatrixAction action)"""
        return _coin.SoArray_getMatrix(self, action)


    def search(self, action):
        """search(SoArray self, SoSearchAction action)"""
        return _coin.SoArray_search(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoArray self, SoGetPrimitiveCountAction action)"""
        return _coin.SoArray_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoArray self, SoAudioRenderAction action)"""
        return _coin.SoArray_audioRender(self, action)

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(SoAsciiText self) -> SoType"""
        return _coin.SoAsciiText_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoAsciiText 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, action):
        """GLRender(SoAsciiText self, SoGLRenderAction action)"""
        return _coin.SoAsciiText_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoAsciiText self, SoGetPrimitiveCountAction action)"""
        return _coin.SoAsciiText_getPrimitiveCount(self, action)

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(SoBaseColor self) -> SoType"""
        return _coin.SoBaseColor_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoBaseColor 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, action):
        """doAction(SoBaseColor self, SoAction action)"""
        return _coin.SoBaseColor_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoBaseColor self, SoGLRenderAction action)"""
        return _coin.SoBaseColor_GLRender(self, action)


    def callback(self, action):
        """callback(SoBaseColor self, SoCallbackAction action)"""
        return _coin.SoBaseColor_callback(self, action)

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()


_coin.SO_SWITCH_NONE_swigconstant(_coin)
SO_SWITCH_NONE = _coin.SO_SWITCH_NONE

_coin.SO_SWITCH_INHERIT_swigconstant(_coin)
SO_SWITCH_INHERIT = _coin.SO_SWITCH_INHERIT

_coin.SO_SWITCH_ALL_swigconstant(_coin)
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(SoSwitch self) -> SoType"""
        return _coin.SoSwitch_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoSwitch self) -> SoSwitch
        __init__(SoSwitch 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(SoSwitch self) -> SbBool"""
        return _coin.SoSwitch_affectsState(self)


    def doAction(self, action):
        """doAction(SoSwitch self, SoAction action)"""
        return _coin.SoSwitch_doAction(self, action)


    def callback(self, action):
        """callback(SoSwitch self, SoCallbackAction action)"""
        return _coin.SoSwitch_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoSwitch self, SoGLRenderAction action)"""
        return _coin.SoSwitch_GLRender(self, action)


    def pick(self, action):
        """pick(SoSwitch self, SoPickAction action)"""
        return _coin.SoSwitch_pick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoSwitch_getBoundingBox(self, action)


    def handleEvent(self, action):
        """handleEvent(SoSwitch self, SoHandleEventAction action)"""
        return _coin.SoSwitch_handleEvent(self, action)


    def getMatrix(self, action):
        """getMatrix(SoSwitch self, SoGetMatrixAction action)"""
        return _coin.SoSwitch_getMatrix(self, action)


    def search(self, action):
        """search(SoSwitch self, SoSearchAction action)"""
        return _coin.SoSwitch_search(self, action)


    def write(self, action):
        """write(SoSwitch self, SoWriteAction action)"""
        return _coin.SoSwitch_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoSwitch self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSwitch_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoSwitch self, SoAudioRenderAction action)"""
        return _coin.SoSwitch_audioRender(self, action)


    def notify(self, nl):
        """notify(SoSwitch self, SoNotList nl)"""
        return _coin.SoSwitch_notify(self, nl)

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(SoBlinker self) -> SoType"""
        return _coin.SoBlinker_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoBlinker 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, action):
        """getBoundingBox(SoBlinker self, SoGetBoundingBoxAction action)"""
        return _coin.SoBlinker_getBoundingBox(self, action)


    def write(self, action):
        """write(SoBlinker self, SoWriteAction action)"""
        return _coin.SoBlinker_write(self, action)

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(SoBumpMapCoordinate self) -> SoType"""
        return _coin.SoBumpMapCoordinate_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoBumpMapCoordinate 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, action):
        """doAction(SoBumpMapCoordinate self, SoAction action)"""
        return _coin.SoBumpMapCoordinate_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoBumpMapCoordinate self, SoGLRenderAction action)"""
        return _coin.SoBumpMapCoordinate_GLRender(self, action)


    def callback(self, action):
        """callback(SoBumpMapCoordinate self, SoCallbackAction action)"""
        return _coin.SoBumpMapCoordinate_callback(self, action)


    def pick(self, action):
        """pick(SoBumpMapCoordinate self, SoPickAction action)"""
        return _coin.SoBumpMapCoordinate_pick(self, action)

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(SoBumpMap self) -> SoType"""
        return _coin.SoBumpMap_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoBumpMap 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, action):
        """doAction(SoBumpMap self, SoAction action)"""
        return _coin.SoBumpMap_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoBumpMap self, SoGLRenderAction action)"""
        return _coin.SoBumpMap_GLRender(self, action)


    def callback(self, action):
        """callback(SoBumpMap self, SoCallbackAction action)"""
        return _coin.SoBumpMap_callback(self, action)


    def rayPick(self, action):
        """rayPick(SoBumpMap self, SoRayPickAction action)"""
        return _coin.SoBumpMap_rayPick(self, action)

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(SoBumpMapTransform self) -> SoType"""
        return _coin.SoBumpMapTransform_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoBumpMapTransform 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, action):
        """doAction(SoBumpMapTransform self, SoAction action)"""
        return _coin.SoBumpMapTransform_doAction(self, action)


    def callback(self, action):
        """callback(SoBumpMapTransform self, SoCallbackAction action)"""
        return _coin.SoBumpMapTransform_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoBumpMapTransform self, SoGLRenderAction action)"""
        return _coin.SoBumpMapTransform_GLRender(self, action)


    def getMatrix(self, action):
        """getMatrix(SoBumpMapTransform self, SoGetMatrixAction action)"""
        return _coin.SoBumpMapTransform_getMatrix(self, action)


    def pick(self, action):
        """pick(SoBumpMapTransform self, SoPickAction action)"""
        return _coin.SoBumpMapTransform_pick(self, action)

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(SoCallback self) -> SoType"""
        return _coin.SoCallback_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCallback self) -> SoCallback"""
        this = _coin.new_SoCallback()
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoCallback self, SoAction action)"""
        return _coin.SoCallback_doAction(self, action)


    def callback(self, action):
        """callback(SoCallback self, SoCallbackAction action)"""
        return _coin.SoCallback_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoCallback self, SoGLRenderAction action)"""
        return _coin.SoCallback_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoCallback self, SoGetBoundingBoxAction action)"""
        return _coin.SoCallback_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoCallback self, SoGetMatrixAction action)"""
        return _coin.SoCallback_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoCallback self, SoHandleEventAction action)"""
        return _coin.SoCallback_handleEvent(self, action)


    def pick(self, action):
        """pick(SoCallback self, SoPickAction action)"""
        return _coin.SoCallback_pick(self, action)


    def search(self, action):
        """search(SoCallback self, SoSearchAction action)"""
        return _coin.SoCallback_search(self, action)


    def write(self, action):
        """write(SoCallback self, SoWriteAction action)"""
        return _coin.SoCallback_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoCallback self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCallback_getPrimitiveCount(self, action)


    def setCallback(self, *args):
        """
        setCallback(SoCallback self, SoCallbackCB * function, void * userdata=None)
        setCallback(SoCallback self, SoCallbackCB * function)
        setCallback(SoCallback self, PyObject * pyfunc, PyObject * userdata=None)
        setCallback(SoCallback 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()


_coin.SO_ASPECT_SQUARE_swigconstant(_coin)
SO_ASPECT_SQUARE = _coin.SO_ASPECT_SQUARE

_coin.SO_ASPECT_VIDEO_swigconstant(_coin)
SO_ASPECT_VIDEO = _coin.SO_ASPECT_VIDEO

_coin.SO_ASPECT_35mm_ACADEMY_swigconstant(_coin)
SO_ASPECT_35mm_ACADEMY = _coin.SO_ASPECT_35mm_ACADEMY

_coin.SO_ASPECT_16mm_swigconstant(_coin)
SO_ASPECT_16mm = _coin.SO_ASPECT_16mm

_coin.SO_ASPECT_35mm_FULL_swigconstant(_coin)
SO_ASPECT_35mm_FULL = _coin.SO_ASPECT_35mm_FULL

_coin.SO_ASPECT_70mm_swigconstant(_coin)
SO_ASPECT_70mm = _coin.SO_ASPECT_70mm

_coin.SO_ASPECT_CINEMASCOPE_swigconstant(_coin)
SO_ASPECT_CINEMASCOPE = _coin.SO_ASPECT_CINEMASCOPE

_coin.SO_ASPECT_HDTV_swigconstant(_coin)
SO_ASPECT_HDTV = _coin.SO_ASPECT_HDTV

_coin.SO_ASPECT_PANAVISION_swigconstant(_coin)
SO_ASPECT_PANAVISION = _coin.SO_ASPECT_PANAVISION

_coin.SO_ASPECT_35mm_swigconstant(_coin)
SO_ASPECT_35mm = _coin.SO_ASPECT_35mm

_coin.SO_ASPECT_VISTAVISION_swigconstant(_coin)
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(SoCamera 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(SoCamera self, SbVec3f targetpoint)
        pointAt(SoCamera self, SbVec3f targetpoint, SbVec3f upvector)
        """
        return _coin.SoCamera_pointAt(self, *args)


    def scaleHeight(self, scalefactor):
        """scaleHeight(SoCamera self, float scalefactor)"""
        return _coin.SoCamera_scaleHeight(self, scalefactor)


    def getViewVolume(self, useaspectratio=0.0):
        """
        getViewVolume(SoCamera self, float useaspectratio=0.0) -> SbViewVolume
        getViewVolume(SoCamera self) -> SbViewVolume
        """
        return _coin.SoCamera_getViewVolume(self, useaspectratio)


    def viewAll(self, *args):
        """
        viewAll(SoCamera self, SoNode sceneroot, SbViewportRegion vpregion, float const slack=1.0)
        viewAll(SoCamera self, SoNode sceneroot, SbViewportRegion vpregion)
        viewAll(SoCamera self, SoPath path, SbViewportRegion vpregion, float const slack=1.0)
        viewAll(SoCamera self, SoPath path, SbViewportRegion vpregion)
        """
        return _coin.SoCamera_viewAll(self, *args)


    def getViewportBounds(self, region):
        """getViewportBounds(SoCamera self, SbViewportRegion region) -> SbViewportRegion"""
        return _coin.SoCamera_getViewportBounds(self, region)

    MONOSCOPIC = _coin.SoCamera_MONOSCOPIC
    LEFT_VIEW = _coin.SoCamera_LEFT_VIEW
    RIGHT_VIEW = _coin.SoCamera_RIGHT_VIEW

    def setStereoMode(self, mode):
        """setStereoMode(SoCamera self, SoCamera::StereoMode mode)"""
        return _coin.SoCamera_setStereoMode(self, mode)


    def getStereoMode(self):
        """getStereoMode(SoCamera self) -> SoCamera::StereoMode"""
        return _coin.SoCamera_getStereoMode(self)


    def setStereoAdjustment(self, adjustment):
        """setStereoAdjustment(SoCamera self, float adjustment)"""
        return _coin.SoCamera_setStereoAdjustment(self, adjustment)


    def getStereoAdjustment(self):
        """getStereoAdjustment(SoCamera self) -> float"""
        return _coin.SoCamera_getStereoAdjustment(self)


    def setBalanceAdjustment(self, adjustment):
        """setBalanceAdjustment(SoCamera self, float adjustment)"""
        return _coin.SoCamera_setBalanceAdjustment(self, adjustment)


    def getBalanceAdjustment(self):
        """getBalanceAdjustment(SoCamera self) -> float"""
        return _coin.SoCamera_getBalanceAdjustment(self)


    def doAction(self, action):
        """doAction(SoCamera self, SoAction action)"""
        return _coin.SoCamera_doAction(self, action)


    def callback(self, action):
        """callback(SoCamera self, SoCallbackAction action)"""
        return _coin.SoCamera_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoCamera self, SoGLRenderAction action)"""
        return _coin.SoCamera_GLRender(self, action)


    def audioRender(self, action):
        """audioRender(SoCamera self, SoAudioRenderAction action)"""
        return _coin.SoCamera_audioRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoCamera self, SoGetBoundingBoxAction action)"""
        return _coin.SoCamera_getBoundingBox(self, action)


    def handleEvent(self, action):
        """handleEvent(SoCamera self, SoHandleEventAction action)"""
        return _coin.SoCamera_handleEvent(self, action)


    def rayPick(self, action):
        """rayPick(SoCamera self, SoRayPickAction action)"""
        return _coin.SoCamera_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoCamera self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCamera_getPrimitiveCount(self, action)

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(SoColorIndex self) -> SoType"""
        return _coin.SoColorIndex_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoColorIndex 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, action):
        """GLRender(SoColorIndex self, SoGLRenderAction action)"""
        return _coin.SoColorIndex_GLRender(self, action)

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(SoCone self) -> SoType"""
        return _coin.SoCone_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCone 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, part):
        """addPart(SoCone self, SoCone::Part part)"""
        return _coin.SoCone_addPart(self, part)


    def removePart(self, part):
        """removePart(SoCone self, SoCone::Part part)"""
        return _coin.SoCone_removePart(self, part)


    def hasPart(self, part):
        """hasPart(SoCone self, SoCone::Part part) -> SbBool"""
        return _coin.SoCone_hasPart(self, part)


    def GLRender(self, action):
        """GLRender(SoCone self, SoGLRenderAction action)"""
        return _coin.SoCone_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoCone self, SoRayPickAction action)"""
        return _coin.SoCone_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoCone self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCone_getPrimitiveCount(self, action)

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(SoCoordinate3 self) -> SoType"""
        return _coin.SoCoordinate3_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCoordinate3 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, action):
        """doAction(SoCoordinate3 self, SoAction action)"""
        return _coin.SoCoordinate3_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoCoordinate3_GLRender(self, action)


    def callback(self, action):
        """callback(SoCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoCoordinate3_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoCoordinate3 self, SoGetBoundingBoxAction action)"""
        return _coin.SoCoordinate3_getBoundingBox(self, action)


    def pick(self, action):
        """pick(SoCoordinate3 self, SoPickAction action)"""
        return _coin.SoCoordinate3_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoCoordinate3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCoordinate3_getPrimitiveCount(self, action)

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(SoCoordinate4 self) -> SoType"""
        return _coin.SoCoordinate4_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCoordinate4 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, action):
        """doAction(SoCoordinate4 self, SoAction action)"""
        return _coin.SoCoordinate4_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoCoordinate4 self, SoGLRenderAction action)"""
        return _coin.SoCoordinate4_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoCoordinate4 self, SoGetBoundingBoxAction action)"""
        return _coin.SoCoordinate4_getBoundingBox(self, action)


    def callback(self, action):
        """callback(SoCoordinate4 self, SoCallbackAction action)"""
        return _coin.SoCoordinate4_callback(self, action)


    def pick(self, action):
        """pick(SoCoordinate4 self, SoPickAction action)"""
        return _coin.SoCoordinate4_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoCoordinate4 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCoordinate4_getPrimitiveCount(self, action)

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(SoCube self) -> SoType"""
        return _coin.SoCube_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCube 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, action):
        """GLRender(SoCube self, SoGLRenderAction action)"""
        return _coin.SoCube_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoCube self, SoRayPickAction action)"""
        return _coin.SoCube_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoCube self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCube_getPrimitiveCount(self, action)

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(SoCylinder self) -> SoType"""
        return _coin.SoCylinder_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCylinder 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, part):
        """addPart(SoCylinder self, SoCylinder::Part part)"""
        return _coin.SoCylinder_addPart(self, part)


    def removePart(self, part):
        """removePart(SoCylinder self, SoCylinder::Part part)"""
        return _coin.SoCylinder_removePart(self, part)


    def hasPart(self, part):
        """hasPart(SoCylinder self, SoCylinder::Part part) -> SbBool"""
        return _coin.SoCylinder_hasPart(self, part)


    def rayPick(self, action):
        """rayPick(SoCylinder self, SoRayPickAction action)"""
        return _coin.SoCylinder_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoCylinder self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCylinder_getPrimitiveCount(self, action)


    def GLRender(self, action):
        """GLRender(SoCylinder self, SoGLRenderAction action)"""
        return _coin.SoCylinder_GLRender(self, action)

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(SoEnvironment self) -> SoType"""
        return _coin.SoEnvironment_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoEnvironment 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, action):
        """GLRender(SoEnvironment self, SoGLRenderAction action)"""
        return _coin.SoEnvironment_GLRender(self, action)


    def callback(self, action):
        """callback(SoEnvironment self, SoCallbackAction action)"""
        return _coin.SoEnvironment_callback(self, action)

    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(SoEventCallback self) -> SoType"""
        return _coin.SoEventCallback_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoEventCallback self) -> SoEventCallback"""
        this = _coin.new_SoEventCallback()
        try:
            self.this.append(this)
        except:
            self.this = this

    def setPath(self, path):
        """setPath(SoEventCallback self, SoPath path)"""
        return _coin.SoEventCallback_setPath(self, path)


    def getPath(self):
        """getPath(SoEventCallback self) -> SoPath"""
        return _coin.SoEventCallback_getPath(self)


    def getAction(self):
        """getAction(SoEventCallback self) -> SoHandleEventAction"""
        return _coin.SoEventCallback_getAction(self)


    def getEvent(self):
        """getEvent(SoEventCallback self) -> SoEvent"""
        return _coin.SoEventCallback_getEvent(self)


    def getPickedPoint(self):
        """getPickedPoint(SoEventCallback self) -> SoPickedPoint"""
        return _coin.SoEventCallback_getPickedPoint(self)


    def setHandled(self):
        """setHandled(SoEventCallback self)"""
        return _coin.SoEventCallback_setHandled(self)


    def isHandled(self):
        """isHandled(SoEventCallback self) -> SbBool"""
        return _coin.SoEventCallback_isHandled(self)


    def grabEvents(self):
        """grabEvents(SoEventCallback self)"""
        return _coin.SoEventCallback_grabEvents(self)


    def releaseEvents(self):
        """releaseEvents(SoEventCallback self)"""
        return _coin.SoEventCallback_releaseEvents(self)


    def addEventCallback(self, *args):
        """
        addEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f, void * userdata=None)
        addEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f)
        addEventCallback(SoEventCallback self, SoType eventtype, PyObject * pyfunc, PyObject * userdata=None)
        addEventCallback(SoEventCallback self, SoType eventtype, PyObject * pyfunc)
        """
        return _coin.SoEventCallback_addEventCallback(self, *args)


    def removeEventCallback(self, *args):
        """
        removeEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f, void * userdata=None)
        removeEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f)
        removeEventCallback(SoEventCallback self, SoType eventtype, PyObject * pyfunc, PyObject * userdata=None)
        removeEventCallback(SoEventCallback 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(SoSelection 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__(SoSelection self) -> SoSelection
        __init__(SoSelection self, int const nChildren) -> SoSelection
        """
        this = _coin.new_SoSelection(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def select(self, *args):
        """
        select(SoSelection self, SoPath path)
        select(SoSelection self, SoNode node)
        """
        return _coin.SoSelection_select(self, *args)


    def deselect(self, *args):
        """
        deselect(SoSelection self, SoPath path)
        deselect(SoSelection self, int const which)
        deselect(SoSelection self, SoNode node)
        """
        return _coin.SoSelection_deselect(self, *args)


    def toggle(self, *args):
        """
        toggle(SoSelection self, SoPath path)
        toggle(SoSelection self, SoNode node)
        """
        return _coin.SoSelection_toggle(self, *args)


    def isSelected(self, *args):
        """
        isSelected(SoSelection self, SoPath path) -> SbBool
        isSelected(SoSelection self, SoNode node) -> SbBool
        """
        return _coin.SoSelection_isSelected(self, *args)


    def deselectAll(self):
        """deselectAll(SoSelection self)"""
        return _coin.SoSelection_deselectAll(self)


    def getNumSelected(self):
        """getNumSelected(SoSelection self) -> int"""
        return _coin.SoSelection_getNumSelected(self)


    def getList(self):
        """getList(SoSelection self) -> SoPathList"""
        return _coin.SoSelection_getList(self)


    def getPath(self, index):
        """getPath(SoSelection self, int const index) -> SoPath"""
        return _coin.SoSelection_getPath(self, index)


    def setPickMatching(self, pickMatching):
        """setPickMatching(SoSelection self, SbBool const pickMatching)"""
        return _coin.SoSelection_setPickMatching(self, pickMatching)


    def isPickMatching(self):
        """isPickMatching(SoSelection self) -> SbBool"""
        return _coin.SoSelection_isPickMatching(self)


    def getPickMatching(self):
        """getPickMatching(SoSelection self) -> SbBool"""
        return _coin.SoSelection_getPickMatching(self)


    def addSelectionCallback(self, *args):
        """
        addSelectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        addSelectionCallback(SoSelection self, SoSelectionPathCB * f)
        addSelectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        addSelectionCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_addSelectionCallback(self, *args)


    def removeSelectionCallback(self, *args):
        """
        removeSelectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        removeSelectionCallback(SoSelection self, SoSelectionPathCB * f)
        removeSelectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        removeSelectionCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_removeSelectionCallback(self, *args)


    def addDeselectionCallback(self, *args):
        """
        addDeselectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        addDeselectionCallback(SoSelection self, SoSelectionPathCB * f)
        addDeselectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        addDeselectionCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_addDeselectionCallback(self, *args)


    def removeDeselectionCallback(self, *args):
        """
        removeDeselectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        removeDeselectionCallback(SoSelection self, SoSelectionPathCB * f)
        removeDeselectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        removeDeselectionCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_removeDeselectionCallback(self, *args)


    def addStartCallback(self, *args):
        """
        addStartCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addStartCallback(SoSelection self, SoSelectionClassCB * f)
        addStartCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        addStartCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_addStartCallback(self, *args)


    def removeStartCallback(self, *args):
        """
        removeStartCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeStartCallback(SoSelection self, SoSelectionClassCB * f)
        removeStartCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        removeStartCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_removeStartCallback(self, *args)


    def addFinishCallback(self, *args):
        """
        addFinishCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addFinishCallback(SoSelection self, SoSelectionClassCB * f)
        addFinishCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        addFinishCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_addFinishCallback(self, *args)


    def removeFinishCallback(self, *args):
        """
        removeFinishCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeFinishCallback(SoSelection self, SoSelectionClassCB * f)
        removeFinishCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        removeFinishCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_removeFinishCallback(self, *args)


    def setPickFilterCallback(self, *args):
        """
        setPickFilterCallback(SoSelection self, SoSelectionPickCB * f, void * userData=None, SbBool const callOnlyIfSelectable=1)
        setPickFilterCallback(SoSelection self, SoSelectionPickCB * f, void * userData=None)
        setPickFilterCallback(SoSelection self, SoSelectionPickCB * f)
        setPickFilterCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None, int callOnlyIfSelectable=1)
        setPickFilterCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        setPickFilterCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_setPickFilterCallback(self, *args)


    def addChangeCallback(self, *args):
        """
        addChangeCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addChangeCallback(SoSelection self, SoSelectionClassCB * f)
        addChangeCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        addChangeCallback(SoSelection self, PyObject * pyfunc)
        """
        return _coin.SoSelection_addChangeCallback(self, *args)


    def removeChangeCallback(self, *args):
        """
        removeChangeCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeChangeCallback(SoSelection self, SoSelectionClassCB * f)
        removeChangeCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        removeChangeCallback(SoSelection 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(SoExtSelection self) -> SoType"""
        return _coin.SoExtSelection_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoExtSelection 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(SoExtSelection self, SbBool overlay=1)
        useOverlay(SoExtSelection self)
        """
        return _coin.SoExtSelection_useOverlay(self, overlay)


    def isUsingOverlay(self):
        """isUsingOverlay(SoExtSelection self) -> SbBool"""
        return _coin.SoExtSelection_isUsingOverlay(self)


    def getOverlaySceneGraph(self):
        """getOverlaySceneGraph(SoExtSelection self) -> SoSeparator"""
        return _coin.SoExtSelection_getOverlaySceneGraph(self)


    def setOverlayLassoColorIndex(self, index):
        """setOverlayLassoColorIndex(SoExtSelection self, int const index)"""
        return _coin.SoExtSelection_setOverlayLassoColorIndex(self, index)


    def getOverlayLassoColorIndex(self):
        """getOverlayLassoColorIndex(SoExtSelection self) -> int"""
        return _coin.SoExtSelection_getOverlayLassoColorIndex(self)


    def setLassoColor(self, color):
        """setLassoColor(SoExtSelection self, SbColor color)"""
        return _coin.SoExtSelection_setLassoColor(self, color)


    def getLassoColor(self):
        """getLassoColor(SoExtSelection self) -> SbColor"""
        return _coin.SoExtSelection_getLassoColor(self)


    def setLassoWidth(self, width):
        """setLassoWidth(SoExtSelection self, float const width)"""
        return _coin.SoExtSelection_setLassoWidth(self, width)


    def getLassoWidth(self):
        """getLassoWidth(SoExtSelection self) -> float"""
        return _coin.SoExtSelection_getLassoWidth(self)


    def setOverlayLassoPattern(self, pattern):
        """setOverlayLassoPattern(SoExtSelection self, unsigned short const pattern)"""
        return _coin.SoExtSelection_setOverlayLassoPattern(self, pattern)


    def getOverlayLassoPattern(self):
        """getOverlayLassoPattern(SoExtSelection self) -> unsigned short"""
        return _coin.SoExtSelection_getOverlayLassoPattern(self)


    def animateOverlayLasso(self, animate=1):
        """
        animateOverlayLasso(SoExtSelection self, SbBool const animate=1)
        animateOverlayLasso(SoExtSelection self)
        """
        return _coin.SoExtSelection_animateOverlayLasso(self, animate)


    def isOverlayLassoAnimated(self):
        """isOverlayLassoAnimated(SoExtSelection self) -> SbBool"""
        return _coin.SoExtSelection_isOverlayLassoAnimated(self)


    def handleEvent(self, action):
        """handleEvent(SoExtSelection self, SoHandleEventAction action)"""
        return _coin.SoExtSelection_handleEvent(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoExtSelection self, SoGLRenderAction action)"""
        return _coin.SoExtSelection_GLRenderBelowPath(self, action)


    def select(self, *args):
        """
        select(SoExtSelection self, SoNode root, int numcoords, SbVec2f lasso, SbViewportRegion vp, SbBool shiftpolicy)
        select(SoExtSelection self, SoNode root, int numcoords, SbVec3f lasso, SbViewportRegion vp, SbBool shiftkeypolicy)
        """
        return _coin.SoExtSelection_select(self, *args)


    def getLassoCoordsDC(self, numCoords):
        """getLassoCoordsDC(SoExtSelection self, int & numCoords) -> SbVec2s"""
        return _coin.SoExtSelection_getLassoCoordsDC(self, numCoords)


    def getLassoCoordsWC(self, numCoords):
        """getLassoCoordsWC(SoExtSelection self, int & numCoords) -> SbVec3f"""
        return _coin.SoExtSelection_getLassoCoordsWC(self, numCoords)


    def getSelectionPathList(self):
        """getSelectionPathList(SoExtSelection self) -> SoPathList"""
        return _coin.SoExtSelection_getSelectionPathList(self)


    def setLassoFilterCallback(self, f, userdata=None, callonlyifselectable=1):
        """
        setLassoFilterCallback(SoExtSelection self, SoLassoSelectionFilterCB * f, void * userdata=None, SbBool const callonlyifselectable=1)
        setLassoFilterCallback(SoExtSelection self, SoLassoSelectionFilterCB * f, void * userdata=None)
        setLassoFilterCallback(SoExtSelection self, SoLassoSelectionFilterCB * f)
        """
        return _coin.SoExtSelection_setLassoFilterCallback(self, f, userdata, callonlyifselectable)


    def setTriangleFilterCallback(self, func, userdata=None):
        """
        setTriangleFilterCallback(SoExtSelection self, SoExtSelectionTriangleCB * func, void * userdata=None)
        setTriangleFilterCallback(SoExtSelection self, SoExtSelectionTriangleCB * func)
        """
        return _coin.SoExtSelection_setTriangleFilterCallback(self, func, userdata)


    def setLineSegmentFilterCallback(self, func, userdata=None):
        """
        setLineSegmentFilterCallback(SoExtSelection self, SoExtSelectionLineSegmentCB * func, void * userdata=None)
        setLineSegmentFilterCallback(SoExtSelection self, SoExtSelectionLineSegmentCB * func)
        """
        return _coin.SoExtSelection_setLineSegmentFilterCallback(self, func, userdata)


    def setPointFilterCallback(self, func, userdata=None):
        """
        setPointFilterCallback(SoExtSelection self, SoExtSelectionPointCB * func, void * userdata=None)
        setPointFilterCallback(SoExtSelection self, SoExtSelectionPointCB * func)
        """
        return _coin.SoExtSelection_setPointFilterCallback(self, func, userdata)


    def wasShiftDown(self):
        """wasShiftDown(SoExtSelection 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(SoVertexProperty self) -> SoType"""
        return _coin.SoVertexProperty_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVertexProperty 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, action):
        """doAction(SoVertexProperty self, SoAction action)"""
        return _coin.SoVertexProperty_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVertexProperty self, SoGLRenderAction action)"""
        return _coin.SoVertexProperty_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVertexProperty self, SoGetBoundingBoxAction action)"""
        return _coin.SoVertexProperty_getBoundingBox(self, action)


    def callback(self, action):
        """callback(SoVertexProperty self, SoCallbackAction action)"""
        return _coin.SoVertexProperty_callback(self, action)


    def pick(self, action):
        """pick(SoVertexProperty self, SoPickAction action)"""
        return _coin.SoVertexProperty_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVertexProperty self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVertexProperty_getPrimitiveCount(self, action)

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(SoVertexShape 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, nl):
        """notify(SoVertexShape self, SoNotList nl)"""
        return _coin.SoVertexShape_notify(self, nl)


    def generateDefaultNormals(self, *args):
        """
        generateDefaultNormals(SoVertexShape self, SoState state, SoNormalBundle bundle) -> SbBool
        generateDefaultNormals(SoVertexShape self, SoState state, SoNormalCache cache) -> SbBool
        """
        return _coin.SoVertexShape_generateDefaultNormals(self, *args)


    def write(self, action):
        """write(SoVertexShape self, SoWriteAction action)"""
        return _coin.SoVertexShape_write(self, action)

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(SoNonIndexedShape 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(SoFaceSet self) -> SoType"""
        return _coin.SoFaceSet_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoFaceSet 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, action):
        """GLRender(SoFaceSet self, SoGLRenderAction action)"""
        return _coin.SoFaceSet_GLRender(self, action)


    def generateDefaultNormals(self, state, nb):
        """generateDefaultNormals(SoFaceSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoFaceSet_generateDefaultNormals(self, state, nb)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFaceSet_getPrimitiveCount(self, action)

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(SoFile self) -> SoType"""
        return _coin.SoFile_getTypeId(self)


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

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoFile 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, action):
        """doAction(SoFile self, SoAction action)"""
        return _coin.SoFile_doAction(self, action)


    def callback(self, action):
        """callback(SoFile self, SoCallbackAction action)"""
        return _coin.SoFile_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoFile self, SoGLRenderAction action)"""
        return _coin.SoFile_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoFile self, SoGetBoundingBoxAction action)"""
        return _coin.SoFile_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoFile self, SoGetMatrixAction action)"""
        return _coin.SoFile_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoFile self, SoHandleEventAction action)"""
        return _coin.SoFile_handleEvent(self, action)


    def pick(self, action):
        """pick(SoFile self, SoPickAction action)"""
        return _coin.SoFile_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoFile self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFile_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoFile self, SoAudioRenderAction action)"""
        return _coin.SoFile_audioRender(self, action)


    def search(self, action):
        """search(SoFile self, SoSearchAction action)"""
        return _coin.SoFile_search(self, action)


    def copyChildren(self):
        """copyChildren(SoFile self) -> SoGroup"""
        return _coin.SoFile_copyChildren(self)


    def getChildren(self):
        """getChildren(SoFile self) -> SoChildList"""
        return _coin.SoFile_getChildren(self)


    def copyContents(self, arg2, copyconnections):
        """copyContents(SoFile self, SoFieldContainer arg2, SbBool copyconnections)"""
        return _coin.SoFile_copyContents(self, arg2, copyconnections)


    def getFullName(self):
        """getFullName(SoFile self) -> SbString"""
        return _coin.SoFile_getFullName(self)


    def setSearchOK(dosearch):
        """setSearchOK(SbBool dosearch)"""
        return _coin.SoFile_setSearchOK(dosearch)

    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(dosearch):
    """SoFile_setSearchOK(SbBool dosearch)"""
    return _coin.SoFile_setSearchOK(dosearch)

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(SoFont self) -> SoType"""
        return _coin.SoFont_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoFont_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoFont 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, action):
        """doAction(SoFont self, SoAction action)"""
        return _coin.SoFont_doAction(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoFont self, SoGetBoundingBoxAction action)"""
        return _coin.SoFont_getBoundingBox(self, action)


    def GLRender(self, action):
        """GLRender(SoFont self, SoGLRenderAction action)"""
        return _coin.SoFont_GLRender(self, action)


    def callback(self, action):
        """callback(SoFont self, SoCallbackAction action)"""
        return _coin.SoFont_callback(self, action)


    def pick(self, action):
        """pick(SoFont self, SoPickAction action)"""
        return _coin.SoFont_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoFont self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFont_getPrimitiveCount(self, action)

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(SoFontStyle self) -> SoType"""
        return _coin.SoFontStyle_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoFontStyle_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoFontStyle 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(SoFontStyle self) -> SbString"""
        return _coin.SoFontStyle_getFontName(self)


    def doAction(self, action):
        """doAction(SoFontStyle self, SoAction action)"""
        return _coin.SoFontStyle_doAction(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoFontStyle self, SoGetBoundingBoxAction action)"""
        return _coin.SoFontStyle_getBoundingBox(self, action)


    def GLRender(self, action):
        """GLRender(SoFontStyle self, SoGLRenderAction action)"""
        return _coin.SoFontStyle_GLRender(self, action)


    def callback(self, action):
        """callback(SoFontStyle self, SoCallbackAction action)"""
        return _coin.SoFontStyle_callback(self, action)


    def pick(self, action):
        """pick(SoFontStyle self, SoPickAction action)"""
        return _coin.SoFontStyle_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoFontStyle self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFontStyle_getPrimitiveCount(self, action)

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(SoIndexedShape 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()


_coin.SO_END_FACE_INDEX_swigconstant(_coin)
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(SoIndexedFaceSet self) -> SoType"""
        return _coin.SoIndexedFaceSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoIndexedFaceSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoIndexedFaceSet self) -> SoIndexedFaceSet"""
        this = _coin.new_SoIndexedFaceSet()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GLRender(self, action):
        """GLRender(SoIndexedFaceSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedFaceSet_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoIndexedFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedFaceSet_getPrimitiveCount(self, action)


    def generateDefaultNormals(self, *args):
        """
        generateDefaultNormals(SoIndexedFaceSet self, SoState state, SoNormalBundle bundle) -> SbBool
        generateDefaultNormals(SoIndexedFaceSet 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()


_coin.SO_END_LINE_INDEX_swigconstant(_coin)
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(SoIndexedLineSet self) -> SoType"""
        return _coin.SoIndexedLineSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoIndexedLineSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoIndexedLineSet self) -> SoIndexedLineSet"""
        this = _coin.new_SoIndexedLineSet()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GLRender(self, action):
        """GLRender(SoIndexedLineSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedLineSet_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoIndexedLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedLineSet_getBoundingBox(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoIndexedLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedLineSet_getPrimitiveCount(self, action)

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(SoIndexedNurbsCurve self) -> SoType"""
        return _coin.SoIndexedNurbsCurve_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoIndexedNurbsCurve_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoIndexedNurbsCurve 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, action):
        """GLRender(SoIndexedNurbsCurve self, SoGLRenderAction action)"""
        return _coin.SoIndexedNurbsCurve_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoIndexedNurbsCurve self, SoRayPickAction action)"""
        return _coin.SoIndexedNurbsCurve_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoIndexedNurbsCurve self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedNurbsCurve_getPrimitiveCount(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoIndexedNurbsCurve self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedNurbsCurve_getBoundingBox(self, action)


    def sendPrimitive(self, arg2, arg3):
        """sendPrimitive(SoIndexedNurbsCurve self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoIndexedNurbsCurve_sendPrimitive(self, arg2, arg3)

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(SoIndexedNurbsSurface self) -> SoType"""
        return _coin.SoIndexedNurbsSurface_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoIndexedNurbsSurface_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoIndexedNurbsSurface 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, action):
        """GLRender(SoIndexedNurbsSurface self, SoGLRenderAction action)"""
        return _coin.SoIndexedNurbsSurface_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoIndexedNurbsSurface self, SoRayPickAction action)"""
        return _coin.SoIndexedNurbsSurface_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoIndexedNurbsSurface self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedNurbsSurface_getPrimitiveCount(self, action)


    def sendPrimitive(self, arg2, arg3):
        """sendPrimitive(SoIndexedNurbsSurface self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoIndexedNurbsSurface_sendPrimitive(self, arg2, arg3)

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()


_coin.SO_END_STRIP_INDEX_swigconstant(_coin)
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(SoIndexedTriangleStripSet self) -> SoType"""
        return _coin.SoIndexedTriangleStripSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoIndexedTriangleStripSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoIndexedTriangleStripSet self) -> SoIndexedTriangleStripSet"""
        this = _coin.new_SoIndexedTriangleStripSet()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GLRender(self, action):
        """GLRender(SoIndexedTriangleStripSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedTriangleStripSet_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoIndexedTriangleStripSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedTriangleStripSet_getPrimitiveCount(self, action)


    def generateDefaultNormals(self, state, nb):
        """generateDefaultNormals(SoIndexedTriangleStripSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoIndexedTriangleStripSet_generateDefaultNormals(self, state, nb)

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(SoInfo self) -> SoType"""
        return _coin.SoInfo_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoInfo_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoInfo 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(SoLabel self) -> SoType"""
        return _coin.SoLabel_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoLabel_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoLabel 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(SoLevelOfDetail self) -> SoType"""
        return _coin.SoLevelOfDetail_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoLevelOfDetail_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoLevelOfDetail self) -> SoLevelOfDetail
        __init__(SoLevelOfDetail 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, action):
        """doAction(SoLevelOfDetail self, SoAction action)"""
        return _coin.SoLevelOfDetail_doAction(self, action)


    def callback(self, action):
        """callback(SoLevelOfDetail self, SoCallbackAction action)"""
        return _coin.SoLevelOfDetail_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoLevelOfDetail self, SoGLRenderAction action)"""
        return _coin.SoLevelOfDetail_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoLevelOfDetail self, SoRayPickAction action)"""
        return _coin.SoLevelOfDetail_rayPick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoLevelOfDetail self, SoGetBoundingBoxAction action)"""
        return _coin.SoLevelOfDetail_getBoundingBox(self, action)


    def audioRender(self, action):
        """audioRender(SoLevelOfDetail self, SoAudioRenderAction action)"""
        return _coin.SoLevelOfDetail_audioRender(self, action)


    def notify(self, nl):
        """notify(SoLevelOfDetail self, SoNotList nl)"""
        return _coin.SoLevelOfDetail_notify(self, nl)

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(SoProfile 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, action):
        """doAction(SoProfile self, SoAction action)"""
        return _coin.SoProfile_doAction(self, action)


    def callback(self, action):
        """callback(SoProfile self, SoCallbackAction action)"""
        return _coin.SoProfile_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoProfile self, SoGLRenderAction action)"""
        return _coin.SoProfile_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoProfile self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfile_getBoundingBox(self, action)


    def pick(self, action):
        """pick(SoProfile self, SoPickAction action)"""
        return _coin.SoProfile_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoProfile self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfile_getPrimitiveCount(self, action)


    def getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector):
        """getTrimCurve(SoProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"""
        return _coin.SoProfile_getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector)


    def getVertices(self, state, numvertices, vertices):
        """getVertices(SoProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoProfile_getVertices(self, state, numvertices, vertices)

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(SoLinearProfile self) -> SoType"""
        return _coin.SoLinearProfile_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoLinearProfile_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoLinearProfile self) -> SoLinearProfile"""
        this = _coin.new_SoLinearProfile()
        try:
            self.this.append(this)
        except:
            self.this = this

    def getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector):
        """getTrimCurve(SoLinearProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"""
        return _coin.SoLinearProfile_getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector)


    def getVertices(self, state, numvertices, vertices):
        """getVertices(SoLinearProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoLinearProfile_getVertices(self, state, numvertices, vertices)

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(SoLineSet self) -> SoType"""
        return _coin.SoLineSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoLineSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoLineSet 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, action):
        """GLRender(SoLineSet self, SoGLRenderAction action)"""
        return _coin.SoLineSet_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoLineSet_getBoundingBox(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoLineSet_getPrimitiveCount(self, action)

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(SoListener self) -> SoType"""
        return _coin.SoListener_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoListener_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoListener 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(SoLocateHighlight self) -> SoType"""
        return _coin.SoLocateHighlight_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoLocateHighlight_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoLocateHighlight 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, action):
        """handleEvent(SoLocateHighlight self, SoHandleEventAction action)"""
        return _coin.SoLocateHighlight_handleEvent(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoLocateHighlight self, SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_GLRenderBelowPath(self, action)


    def GLRenderInPath(self, action):
        """GLRenderInPath(SoLocateHighlight self, SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_GLRenderInPath(self, action)


    def turnOffCurrentHighlight(action):
        """turnOffCurrentHighlight(SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_turnOffCurrentHighlight(action)

    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(action):
    """SoLocateHighlight_turnOffCurrentHighlight(SoGLRenderAction action)"""
    return _coin.SoLocateHighlight_turnOffCurrentHighlight(action)

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(SoLOD self) -> SoType"""
        return _coin.SoLOD_getTypeId(self)


    def __init__(self, *args):
        """
        __init__(SoLOD self) -> SoLOD
        __init__(SoLOD 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, action):
        """doAction(SoLOD self, SoAction action)"""
        return _coin.SoLOD_doAction(self, action)


    def callback(self, action):
        """callback(SoLOD self, SoCallbackAction action)"""
        return _coin.SoLOD_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRender(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderBelowPath(self, action)


    def GLRenderInPath(self, action):
        """GLRenderInPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderInPath(self, action)


    def GLRenderOffPath(self, action):
        """GLRenderOffPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderOffPath(self, action)


    def rayPick(self, action):
        """rayPick(SoLOD self, SoRayPickAction action)"""
        return _coin.SoLOD_rayPick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoLOD self, SoGetBoundingBoxAction action)"""
        return _coin.SoLOD_getBoundingBox(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoLOD self, SoGetPrimitiveCountAction action)"""
        return _coin.SoLOD_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoLOD self, SoAudioRenderAction action)"""
        return _coin.SoLOD_audioRender(self, action)


    def notify(self, nl):
        """notify(SoLOD self, SoNotList nl)"""
        return _coin.SoLOD_notify(self, nl)

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(SoPointSet self) -> SoType"""
        return _coin.SoPointSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoPointSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPointSet 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, action):
        """GLRender(SoPointSet self, SoGLRenderAction action)"""
        return _coin.SoPointSet_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoPointSet_getBoundingBox(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoPointSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoPointSet_getPrimitiveCount(self, action)

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(SoMarkerSet self) -> SoType"""
        return _coin.SoMarkerSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoMarkerSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoMarkerSet 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, action):
        """GLRender(SoMarkerSet self, SoGLRenderAction action)"""
        return _coin.SoMarkerSet_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoMarkerSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMarkerSet_getPrimitiveCount(self, action)


    def getNumDefinedMarkers():
        """getNumDefinedMarkers() -> int"""
        return _coin.SoMarkerSet_getNumDefinedMarkers()

    getNumDefinedMarkers = staticmethod(getNumDefinedMarkers)

    def addMarker(idx, size, bytes, isLSBFirst=1, isUpToDown=1):
        """
        addMarker(int idx, SbVec2s size, unsigned char const * bytes, SbBool isLSBFirst=1, SbBool isUpToDown=1)
        addMarker(int idx, SbVec2s size, unsigned char const * bytes, SbBool isLSBFirst=1)
        addMarker(int idx, SbVec2s size, unsigned char const * bytes)
        """
        return _coin.SoMarkerSet_addMarker(idx, size, bytes, isLSBFirst, isUpToDown)

    addMarker = staticmethod(addMarker)

    def getMarker(idx, size, bytes, isLSBFirst):
        """getMarker(int idx, SbVec2s size, unsigned char const *& bytes, SbBool & isLSBFirst) -> SbBool"""
        return _coin.SoMarkerSet_getMarker(idx, size, bytes, isLSBFirst)

    getMarker = staticmethod(getMarker)

    def removeMarker(idx):
        """removeMarker(int idx) -> SbBool"""
        return _coin.SoMarkerSet_removeMarker(idx)

    removeMarker = staticmethod(removeMarker)

    def isMarkerBitSet(idx, bitNumber):
        """isMarkerBitSet(int idx, int bitNumber) -> SbBool"""
        return _coin.SoMarkerSet_isMarkerBitSet(idx, bitNumber)

    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(idx, size, bytes, isLSBFirst=1, isUpToDown=1):
    """
    addMarker(int idx, SbVec2s size, unsigned char const * bytes, SbBool isLSBFirst=1, SbBool isUpToDown=1)
    addMarker(int idx, SbVec2s size, unsigned char const * bytes, SbBool isLSBFirst=1)
    SoMarkerSet_addMarker(int idx, SbVec2s size, unsigned char const * bytes)
    """
    return _coin.SoMarkerSet_addMarker(idx, size, bytes, isLSBFirst, isUpToDown)

def SoMarkerSet_getMarker(idx, size, bytes, isLSBFirst):
    """SoMarkerSet_getMarker(int idx, SbVec2s size, unsigned char const *& bytes, SbBool & isLSBFirst) -> SbBool"""
    return _coin.SoMarkerSet_getMarker(idx, size, bytes, isLSBFirst)

def SoMarkerSet_removeMarker(idx):
    """SoMarkerSet_removeMarker(int idx) -> SbBool"""
    return _coin.SoMarkerSet_removeMarker(idx)

def SoMarkerSet_isMarkerBitSet(idx, bitNumber):
    """SoMarkerSet_isMarkerBitSet(int idx, int bitNumber) -> SbBool"""
    return _coin.SoMarkerSet_isMarkerBitSet(idx, bitNumber)

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(SoMaterial self) -> SoType"""
        return _coin.SoMaterial_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoMaterial_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoMaterial 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, action):
        """doAction(SoMaterial self, SoAction action)"""
        return _coin.SoMaterial_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoMaterial self, SoGLRenderAction action)"""
        return _coin.SoMaterial_GLRender(self, action)


    def callback(self, action):
        """callback(SoMaterial self, SoCallbackAction action)"""
        return _coin.SoMaterial_callback(self, action)

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(SoMatrixTransform self) -> SoType"""
        return _coin.SoMatrixTransform_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoMatrixTransform_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoMatrixTransform 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, action):
        """doAction(SoMatrixTransform self, SoAction action)"""
        return _coin.SoMatrixTransform_doAction(self, action)


    def callback(self, action):
        """callback(SoMatrixTransform self, SoCallbackAction action)"""
        return _coin.SoMatrixTransform_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoMatrixTransform self, SoGLRenderAction action)"""
        return _coin.SoMatrixTransform_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoMatrixTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoMatrixTransform_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoMatrixTransform self, SoGetMatrixAction action)"""
        return _coin.SoMatrixTransform_getMatrix(self, action)


    def pick(self, action):
        """pick(SoMatrixTransform self, SoPickAction action)"""
        return _coin.SoMatrixTransform_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoMatrixTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMatrixTransform_getPrimitiveCount(self, action)

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(SoMultipleCopy self) -> SoType"""
        return _coin.SoMultipleCopy_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoMultipleCopy_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoMultipleCopy 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(SoMultipleCopy self) -> SbBool"""
        return _coin.SoMultipleCopy_affectsState(self)


    def doAction(self, action):
        """doAction(SoMultipleCopy self, SoAction action)"""
        return _coin.SoMultipleCopy_doAction(self, action)


    def callback(self, action):
        """callback(SoMultipleCopy self, SoCallbackAction action)"""
        return _coin.SoMultipleCopy_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoMultipleCopy self, SoGLRenderAction action)"""
        return _coin.SoMultipleCopy_GLRender(self, action)


    def pick(self, action):
        """pick(SoMultipleCopy self, SoPickAction action)"""
        return _coin.SoMultipleCopy_pick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoMultipleCopy self, SoGetBoundingBoxAction action)"""
        return _coin.SoMultipleCopy_getBoundingBox(self, action)


    def handleEvent(self, action):
        """handleEvent(SoMultipleCopy self, SoHandleEventAction action)"""
        return _coin.SoMultipleCopy_handleEvent(self, action)


    def getMatrix(self, action):
        """getMatrix(SoMultipleCopy self, SoGetMatrixAction action)"""
        return _coin.SoMultipleCopy_getMatrix(self, action)


    def search(self, action):
        """search(SoMultipleCopy self, SoSearchAction action)"""
        return _coin.SoMultipleCopy_search(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoMultipleCopy self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMultipleCopy_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoMultipleCopy self, SoAudioRenderAction action)"""
        return _coin.SoMultipleCopy_audioRender(self, action)

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(SoPerspectiveCamera self) -> SoType"""
        return _coin.SoPerspectiveCamera_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoPerspectiveCamera_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPerspectiveCamera 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, scalefactor):
        """scaleHeight(SoPerspectiveCamera self, float scalefactor)"""
        return _coin.SoPerspectiveCamera_scaleHeight(self, scalefactor)


    def getViewVolume(self, useaspectratio=0.0):
        """
        getViewVolume(SoPerspectiveCamera self, float useaspectratio=0.0) -> SbViewVolume
        getViewVolume(SoPerspectiveCamera 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(SoOrthographicCamera self) -> SoType"""
        return _coin.SoOrthographicCamera_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoOrthographicCamera_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoOrthographicCamera 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, scalefactor):
        """scaleHeight(SoOrthographicCamera self, float scalefactor)"""
        return _coin.SoOrthographicCamera_scaleHeight(self, scalefactor)


    def getViewVolume(self, useaspectratio=0.0):
        """
        getViewVolume(SoOrthographicCamera self, float useaspectratio=0.0) -> SbViewVolume
        getViewVolume(SoOrthographicCamera 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(SoFrustumCamera self) -> SoType"""
        return _coin.SoFrustumCamera_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoFrustumCamera_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoFrustumCamera 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, scalefactor):
        """scaleHeight(SoFrustumCamera self, float scalefactor)"""
        return _coin.SoFrustumCamera_scaleHeight(self, scalefactor)


    def getViewVolume(self, useaspectratio=0.0):
        """
        getViewVolume(SoFrustumCamera self, float useaspectratio=0.0) -> SbViewVolume
        getViewVolume(SoFrustumCamera 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(SoQuadMesh self) -> SoType"""
        return _coin.SoQuadMesh_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoQuadMesh_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoQuadMesh 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, action):
        """GLRender(SoQuadMesh self, SoGLRenderAction action)"""
        return _coin.SoQuadMesh_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoQuadMesh self, SoGetPrimitiveCountAction action)"""
        return _coin.SoQuadMesh_getPrimitiveCount(self, action)


    def generateDefaultNormals(self, state, nb):
        """generateDefaultNormals(SoQuadMesh self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoQuadMesh_generateDefaultNormals(self, state, nb)

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(SoTriangleStripSet self) -> SoType"""
        return _coin.SoTriangleStripSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTriangleStripSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTriangleStripSet 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, action):
        """GLRender(SoTriangleStripSet self, SoGLRenderAction action)"""
        return _coin.SoTriangleStripSet_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoTriangleStripSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTriangleStripSet_getPrimitiveCount(self, action)


    def generateDefaultNormals(self, state, nb):
        """generateDefaultNormals(SoTriangleStripSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoTriangleStripSet_generateDefaultNormals(self, state, nb)

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(SoIndexedPointSet self) -> SoType"""
        return _coin.SoIndexedPointSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoIndexedPointSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoIndexedPointSet self) -> SoIndexedPointSet"""
        this = _coin.new_SoIndexedPointSet()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GLRender(self, action):
        """GLRender(SoIndexedPointSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedPointSet_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoIndexedPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedPointSet_getBoundingBox(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoIndexedPointSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedPointSet_getPrimitiveCount(self, action)


    def notify(self, list):
        """notify(SoIndexedPointSet self, SoNotList list)"""
        return _coin.SoIndexedPointSet_notify(self, list)

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(SoIndexedMarkerSet self) -> SoType"""
        return _coin.SoIndexedMarkerSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoIndexedMarkerSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoIndexedMarkerSet 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, action):
        """GLRender(SoIndexedMarkerSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedMarkerSet_GLRender(self, action)


    def notify(self, list):
        """notify(SoIndexedMarkerSet self, SoNotList list)"""
        return _coin.SoIndexedMarkerSet_notify(self, list)

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(SoNurbsCurve self) -> SoType"""
        return _coin.SoNurbsCurve_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoNurbsCurve_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoNurbsCurve 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, action):
        """GLRender(SoNurbsCurve self, SoGLRenderAction action)"""
        return _coin.SoNurbsCurve_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoNurbsCurve self, SoRayPickAction action)"""
        return _coin.SoNurbsCurve_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoNurbsCurve self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNurbsCurve_getPrimitiveCount(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoNurbsCurve self, SoGetBoundingBoxAction action)"""
        return _coin.SoNurbsCurve_getBoundingBox(self, action)


    def sendPrimitive(self, arg2, arg3):
        """sendPrimitive(SoNurbsCurve self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoNurbsCurve_sendPrimitive(self, arg2, arg3)

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(SoNurbsSurface self) -> SoType"""
        return _coin.SoNurbsSurface_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoNurbsSurface_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoNurbsSurface 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, action):
        """GLRender(SoNurbsSurface self, SoGLRenderAction action)"""
        return _coin.SoNurbsSurface_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoNurbsSurface self, SoRayPickAction action)"""
        return _coin.SoNurbsSurface_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoNurbsSurface self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNurbsSurface_getPrimitiveCount(self, action)


    def sendPrimitive(self, arg2, arg3):
        """sendPrimitive(SoNurbsSurface self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoNurbsSurface_sendPrimitive(self, arg2, arg3)

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(SoSphere self) -> SoType"""
        return _coin.SoSphere_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoSphere_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSphere 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, action):
        """GLRender(SoSphere self, SoGLRenderAction action)"""
        return _coin.SoSphere_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoSphere self, SoRayPickAction action)"""
        return _coin.SoSphere_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoSphere self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSphere_getPrimitiveCount(self, action)

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(SoText2 self) -> SoType"""
        return _coin.SoText2_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoText2_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoText2 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, action):
        """GLRender(SoText2 self, SoGLRenderAction action)"""
        return _coin.SoText2_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoText2 self, SoRayPickAction action)"""
        return _coin.SoText2_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoText2 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoText2_getPrimitiveCount(self, action)

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(SoText3 self) -> SoType"""
        return _coin.SoText3_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoText3_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoText3 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, state, stringindex, charindex):
        """getCharacterBounds(SoText3 self, SoState state, int stringindex, int charindex) -> SbBox3f"""
        return _coin.SoText3_getCharacterBounds(self, state, stringindex, charindex)


    def GLRender(self, action):
        """GLRender(SoText3 self, SoGLRenderAction action)"""
        return _coin.SoText3_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoText3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoText3_getPrimitiveCount(self, action)

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(SoWWWAnchor self) -> SoType"""
        return _coin.SoWWWAnchor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoWWWAnchor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoWWWAnchor 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, url):
        """setFullURLName(SoWWWAnchor self, SbString url)"""
        return _coin.SoWWWAnchor_setFullURLName(self, url)


    def getFullURLName(self):
        """getFullURLName(SoWWWAnchor self) -> SbString"""
        return _coin.SoWWWAnchor_getFullURLName(self)


    def handleEvent(self, action):
        """handleEvent(SoWWWAnchor self, SoHandleEventAction action)"""
        return _coin.SoWWWAnchor_handleEvent(self, action)


    def setFetchURLCallBack(f, userData):
        """setFetchURLCallBack(SoWWWAnchorCB * f, void * userData)"""
        return _coin.SoWWWAnchor_setFetchURLCallBack(f, userData)

    setFetchURLCallBack = staticmethod(setFetchURLCallBack)

    def setHighlightURLCallBack(f, userData):
        """setHighlightURLCallBack(SoWWWAnchorCB * f, void * userData)"""
        return _coin.SoWWWAnchor_setHighlightURLCallBack(f, userData)

    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(f, userData):
    """SoWWWAnchor_setFetchURLCallBack(SoWWWAnchorCB * f, void * userData)"""
    return _coin.SoWWWAnchor_setFetchURLCallBack(f, userData)

def SoWWWAnchor_setHighlightURLCallBack(f, userData):
    """SoWWWAnchor_setHighlightURLCallBack(SoWWWAnchorCB * f, void * userData)"""
    return _coin.SoWWWAnchor_setHighlightURLCallBack(f, userData)

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(SoPathSwitch self) -> SoType"""
        return _coin.SoPathSwitch_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoPathSwitch_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoPathSwitch self) -> SoPathSwitch
        __init__(SoPathSwitch 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, action):
        """doAction(SoPathSwitch self, SoAction action)"""
        return _coin.SoPathSwitch_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoPathSwitch self, SoGLRenderAction action)"""
        return _coin.SoPathSwitch_GLRender(self, action)


    def pick(self, action):
        """pick(SoPathSwitch self, SoPickAction action)"""
        return _coin.SoPathSwitch_pick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoPathSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoPathSwitch_getBoundingBox(self, action)


    def handleEvent(self, action):
        """handleEvent(SoPathSwitch self, SoHandleEventAction action)"""
        return _coin.SoPathSwitch_handleEvent(self, action)


    def getMatrix(self, action):
        """getMatrix(SoPathSwitch self, SoGetMatrixAction action)"""
        return _coin.SoPathSwitch_getMatrix(self, action)


    def search(self, action):
        """search(SoPathSwitch self, SoSearchAction action)"""
        return _coin.SoPathSwitch_search(self, action)


    def callback(self, action):
        """callback(SoPathSwitch self, SoCallbackAction action)"""
        return _coin.SoPathSwitch_callback(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoPathSwitch self, SoGetPrimitiveCountAction action)"""
        return _coin.SoPathSwitch_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoPathSwitch self, SoAudioRenderAction action)"""
        return _coin.SoPathSwitch_audioRender(self, action)

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(SoTransformSeparator self) -> SoType"""
        return _coin.SoTransformSeparator_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTransformSeparator_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoTransformSeparator self) -> SoTransformSeparator
        __init__(SoTransformSeparator self, int nChildren) -> SoTransformSeparator
        """
        this = _coin.new_SoTransformSeparator(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoTransformSeparator self, SoAction action)"""
        return _coin.SoTransformSeparator_doAction(self, action)


    def callback(self, action):
        """callback(SoTransformSeparator self, SoCallbackAction action)"""
        return _coin.SoTransformSeparator_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTransformSeparator self, SoGLRenderAction action)"""
        return _coin.SoTransformSeparator_GLRender(self, action)


    def pick(self, action):
        """pick(SoTransformSeparator self, SoPickAction action)"""
        return _coin.SoTransformSeparator_pick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoTransformSeparator self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransformSeparator_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoTransformSeparator self, SoGetMatrixAction action)"""
        return _coin.SoTransformSeparator_getMatrix(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoTransformSeparator self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTransformSeparator_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoTransformSeparator self, SoAudioRenderAction action)"""
        return _coin.SoTransformSeparator_audioRender(self, action)

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(SoRotation self) -> SoType"""
        return _coin.SoRotation_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoRotation_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoRotation 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, action):
        """doAction(SoRotation self, SoAction action)"""
        return _coin.SoRotation_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoRotation self, SoGLRenderAction action)"""
        return _coin.SoRotation_GLRender(self, action)


    def callback(self, action):
        """callback(SoRotation self, SoCallbackAction action)"""
        return _coin.SoRotation_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoRotation self, SoGetBoundingBoxAction action)"""
        return _coin.SoRotation_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoRotation self, SoGetMatrixAction action)"""
        return _coin.SoRotation_getMatrix(self, action)


    def pick(self, action):
        """pick(SoRotation self, SoPickAction action)"""
        return _coin.SoRotation_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoRotation self, SoGetPrimitiveCountAction action)"""
        return _coin.SoRotation_getPrimitiveCount(self, action)

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(SoPendulum self) -> SoType"""
        return _coin.SoPendulum_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoPendulum_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPendulum 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, action):
        """write(SoPendulum self, SoWriteAction action)"""
        return _coin.SoPendulum_write(self, action)

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(SoRotor self) -> SoType"""
        return _coin.SoRotor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoRotor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoRotor 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(SoResetTransform self) -> SoType"""
        return _coin.SoResetTransform_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoResetTransform_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoResetTransform 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, action):
        """doAction(SoResetTransform self, SoAction action)"""
        return _coin.SoResetTransform_doAction(self, action)


    def callback(self, action):
        """callback(SoResetTransform self, SoCallbackAction action)"""
        return _coin.SoResetTransform_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoResetTransform self, SoGLRenderAction action)"""
        return _coin.SoResetTransform_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoResetTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoResetTransform_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoResetTransform self, SoGetMatrixAction action)"""
        return _coin.SoResetTransform_getMatrix(self, action)


    def pick(self, action):
        """pick(SoResetTransform self, SoPickAction action)"""
        return _coin.SoResetTransform_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoResetTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoResetTransform_getPrimitiveCount(self, action)

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(SoRotationXYZ self) -> SoType"""
        return _coin.SoRotationXYZ_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoRotationXYZ_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoRotationXYZ 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(SoRotationXYZ self) -> SbRotation"""
        return _coin.SoRotationXYZ_getRotation(self)


    def doAction(self, action):
        """doAction(SoRotationXYZ self, SoAction action)"""
        return _coin.SoRotationXYZ_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoRotationXYZ self, SoGLRenderAction action)"""
        return _coin.SoRotationXYZ_GLRender(self, action)


    def callback(self, action):
        """callback(SoRotationXYZ self, SoCallbackAction action)"""
        return _coin.SoRotationXYZ_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoRotationXYZ self, SoGetBoundingBoxAction action)"""
        return _coin.SoRotationXYZ_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoRotationXYZ self, SoGetMatrixAction action)"""
        return _coin.SoRotationXYZ_getMatrix(self, action)


    def pick(self, action):
        """pick(SoRotationXYZ self, SoPickAction action)"""
        return _coin.SoRotationXYZ_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoRotationXYZ self, SoGetPrimitiveCountAction action)"""
        return _coin.SoRotationXYZ_getPrimitiveCount(self, action)

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(SoTranslation self) -> SoType"""
        return _coin.SoTranslation_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTranslation_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTranslation 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, action):
        """doAction(SoTranslation self, SoAction action)"""
        return _coin.SoTranslation_doAction(self, action)


    def callback(self, action):
        """callback(SoTranslation self, SoCallbackAction action)"""
        return _coin.SoTranslation_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTranslation self, SoGLRenderAction action)"""
        return _coin.SoTranslation_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoTranslation self, SoGetBoundingBoxAction action)"""
        return _coin.SoTranslation_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoTranslation self, SoGetMatrixAction action)"""
        return _coin.SoTranslation_getMatrix(self, action)


    def pick(self, action):
        """pick(SoTranslation self, SoPickAction action)"""
        return _coin.SoTranslation_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoTranslation self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTranslation_getPrimitiveCount(self, action)

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(SoShuttle self) -> SoType"""
        return _coin.SoShuttle_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoShuttle_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoShuttle 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, action):
        """write(SoShuttle self, SoWriteAction action)"""
        return _coin.SoShuttle_write(self, action)

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(SoSurroundScale self) -> SoType"""
        return _coin.SoSurroundScale_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoSurroundScale_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSurroundScale 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(SoSurroundScale self)"""
        return _coin.SoSurroundScale_invalidate(self)


    def doAction(self, action):
        """doAction(SoSurroundScale self, SoAction action)"""
        return _coin.SoSurroundScale_doAction(self, action)


    def setDoingTranslations(self, val):
        """setDoingTranslations(SoSurroundScale self, SbBool const val)"""
        return _coin.SoSurroundScale_setDoingTranslations(self, val)


    def isDoingTranslations(self):
        """isDoingTranslations(SoSurroundScale 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(SoNurbsProfile self) -> SoType"""
        return _coin.SoNurbsProfile_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoNurbsProfile_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoNurbsProfile 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, state, numpoints, points, floatspervec, numknots, knotvector):
        """getTrimCurve(SoNurbsProfile self, SoState state, int32_t & numpoints, float *& points, int & floatspervec, int32_t & numknots, float *& knotvector)"""
        return _coin.SoNurbsProfile_getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector)


    def getVertices(self, state, numvertices, vertices):
        """getVertices(SoNurbsProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoNurbsProfile_getVertices(self, state, numvertices, vertices)

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__(SoVertexAttribute 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(SoVertexAttribute 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(SoVertexAttribute self) -> SoMField"""
        return _coin.SoVertexAttribute_getValuesField(self)


    def doAction(self, action):
        """doAction(SoVertexAttribute self, SoAction action)"""
        return _coin.SoVertexAttribute_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVertexAttribute self, SoGLRenderAction action)"""
        return _coin.SoVertexAttribute_GLRender(self, action)


    def write(self, action):
        """write(SoVertexAttribute self, SoWriteAction action)"""
        return _coin.SoVertexAttribute_write(self, action)


    def copyContents(self, arg2, copyconnections):
        """copyContents(SoVertexAttribute self, SoFieldContainer arg2, SbBool copyconnections)"""
        return _coin.SoVertexAttribute_copyContents(self, arg2, copyconnections)


    def notify(self, l):
        """notify(SoVertexAttribute self, SoNotList l)"""
        return _coin.SoVertexAttribute_notify(self, l)

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(SoVertexAttributeBinding self) -> SoType"""
        return _coin.SoVertexAttributeBinding_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVertexAttributeBinding_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVertexAttributeBinding 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, action):
        """doAction(SoVertexAttributeBinding self, SoAction action)"""
        return _coin.SoVertexAttributeBinding_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVertexAttributeBinding self, SoGLRenderAction action)"""
        return _coin.SoVertexAttributeBinding_GLRender(self, action)


    def callback(self, action):
        """callback(SoVertexAttributeBinding self, SoCallbackAction action)"""
        return _coin.SoVertexAttributeBinding_callback(self, action)


    def pick(self, action):
        """pick(SoVertexAttributeBinding self, SoPickAction action)"""
        return _coin.SoVertexAttributeBinding_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVertexAttributeBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVertexAttributeBinding_getPrimitiveCount(self, action)

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(SoNormal self) -> SoType"""
        return _coin.SoNormal_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoNormal_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoNormal 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, action):
        """doAction(SoNormal self, SoAction action)"""
        return _coin.SoNormal_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoNormal self, SoGLRenderAction action)"""
        return _coin.SoNormal_GLRender(self, action)


    def callback(self, action):
        """callback(SoNormal self, SoCallbackAction action)"""
        return _coin.SoNormal_callback(self, action)


    def pick(self, action):
        """pick(SoNormal self, SoPickAction action)"""
        return _coin.SoNormal_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoNormal self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNormal_getPrimitiveCount(self, action)

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(SoPackedColor self) -> SoType"""
        return _coin.SoPackedColor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoPackedColor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPackedColor 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, action):
        """doAction(SoPackedColor self, SoAction action)"""
        return _coin.SoPackedColor_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoPackedColor self, SoGLRenderAction action)"""
        return _coin.SoPackedColor_GLRender(self, action)


    def callback(self, action):
        """callback(SoPackedColor self, SoCallbackAction action)"""
        return _coin.SoPackedColor_callback(self, action)


    def isTransparent(self):
        """isTransparent(SoPackedColor 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(SoPolygonOffset self) -> SoType"""
        return _coin.SoPolygonOffset_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoPolygonOffset_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoPolygonOffset 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, action):
        """doAction(SoPolygonOffset self, SoAction action)"""
        return _coin.SoPolygonOffset_doAction(self, action)


    def callback(self, action):
        """callback(SoPolygonOffset self, SoCallbackAction action)"""
        return _coin.SoPolygonOffset_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoPolygonOffset self, SoGLRenderAction action)"""
        return _coin.SoPolygonOffset_GLRender(self, action)

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(SoProfileCoordinate2 self) -> SoType"""
        return _coin.SoProfileCoordinate2_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoProfileCoordinate2_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoProfileCoordinate2 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, action):
        """doAction(SoProfileCoordinate2 self, SoAction action)"""
        return _coin.SoProfileCoordinate2_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoProfileCoordinate2 self, SoGLRenderAction action)"""
        return _coin.SoProfileCoordinate2_GLRender(self, action)


    def callback(self, action):
        """callback(SoProfileCoordinate2 self, SoCallbackAction action)"""
        return _coin.SoProfileCoordinate2_callback(self, action)


    def pick(self, action):
        """pick(SoProfileCoordinate2 self, SoPickAction action)"""
        return _coin.SoProfileCoordinate2_pick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoProfileCoordinate2 self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfileCoordinate2_getBoundingBox(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoProfileCoordinate2 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfileCoordinate2_getPrimitiveCount(self, action)

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(SoProfileCoordinate3 self) -> SoType"""
        return _coin.SoProfileCoordinate3_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoProfileCoordinate3_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoProfileCoordinate3 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, action):
        """doAction(SoProfileCoordinate3 self, SoAction action)"""
        return _coin.SoProfileCoordinate3_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoProfileCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoProfileCoordinate3_GLRender(self, action)


    def callback(self, action):
        """callback(SoProfileCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoProfileCoordinate3_callback(self, action)


    def pick(self, action):
        """pick(SoProfileCoordinate3 self, SoPickAction action)"""
        return _coin.SoProfileCoordinate3_pick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoProfileCoordinate3 self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfileCoordinate3_getBoundingBox(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoProfileCoordinate3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfileCoordinate3_getPrimitiveCount(self, action)

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(SoTexture3 self) -> SoType"""
        return _coin.SoTexture3_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTexture3_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTexture3 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, action):
        """doAction(SoTexture3 self, SoAction action)"""
        return _coin.SoTexture3_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTexture3 self, SoGLRenderAction action)"""
        return _coin.SoTexture3_GLRender(self, action)


    def callback(self, action):
        """callback(SoTexture3 self, SoCallbackAction action)"""
        return _coin.SoTexture3_callback(self, action)

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(SoTexture2Transform self) -> SoType"""
        return _coin.SoTexture2Transform_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTexture2Transform_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTexture2Transform 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, action):
        """doAction(SoTexture2Transform self, SoAction action)"""
        return _coin.SoTexture2Transform_doAction(self, action)


    def callback(self, action):
        """callback(SoTexture2Transform self, SoCallbackAction action)"""
        return _coin.SoTexture2Transform_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTexture2Transform self, SoGLRenderAction action)"""
        return _coin.SoTexture2Transform_GLRender(self, action)


    def getMatrix(self, action):
        """getMatrix(SoTexture2Transform self, SoGetMatrixAction action)"""
        return _coin.SoTexture2Transform_getMatrix(self, action)


    def pick(self, action):
        """pick(SoTexture2Transform self, SoPickAction action)"""
        return _coin.SoTexture2Transform_pick(self, action)

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(SoTexture3Transform self) -> SoType"""
        return _coin.SoTexture3Transform_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTexture3Transform_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTexture3Transform 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, action):
        """doAction(SoTexture3Transform self, SoAction action)"""
        return _coin.SoTexture3Transform_doAction(self, action)


    def callback(self, action):
        """callback(SoTexture3Transform self, SoCallbackAction action)"""
        return _coin.SoTexture3Transform_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTexture3Transform self, SoGLRenderAction action)"""
        return _coin.SoTexture3Transform_GLRender(self, action)


    def getMatrix(self, action):
        """getMatrix(SoTexture3Transform self, SoGetMatrixAction action)"""
        return _coin.SoTexture3Transform_getMatrix(self, action)


    def pick(self, action):
        """pick(SoTexture3Transform self, SoPickAction action)"""
        return _coin.SoTexture3Transform_pick(self, action)

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(SoTextureCoordinate2 self) -> SoType"""
        return _coin.SoTextureCoordinate2_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinate2_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinate2 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, action):
        """doAction(SoTextureCoordinate2 self, SoAction action)"""
        return _coin.SoTextureCoordinate2_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinate2 self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinate2_GLRender(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinate2 self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinate2_callback(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinate2 self, SoPickAction action)"""
        return _coin.SoTextureCoordinate2_pick(self, action)

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(SoTextureCoordinate3 self) -> SoType"""
        return _coin.SoTextureCoordinate3_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinate3_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinate3 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, action):
        """doAction(SoTextureCoordinate3 self, SoAction action)"""
        return _coin.SoTextureCoordinate3_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinate3_GLRender(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinate3_callback(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinate3 self, SoPickAction action)"""
        return _coin.SoTextureCoordinate3_pick(self, action)

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(SoTextureCoordinateFunction self) -> SoType"""
        return _coin.SoTextureCoordinateFunction_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateFunction_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateFunction 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(SoTextureCoordinateDefault self) -> SoType"""
        return _coin.SoTextureCoordinateDefault_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateDefault_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateDefault self) -> SoTextureCoordinateDefault"""
        this = _coin.new_SoTextureCoordinateDefault()
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoTextureCoordinateDefault self, SoAction action)"""
        return _coin.SoTextureCoordinateDefault_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateDefault self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateDefault_GLRender(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateDefault self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateDefault_callback(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateDefault self, SoPickAction action)"""
        return _coin.SoTextureCoordinateDefault_pick(self, action)

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(SoTextureCoordinateEnvironment self) -> SoType"""
        return _coin.SoTextureCoordinateEnvironment_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateEnvironment_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateEnvironment self) -> SoTextureCoordinateEnvironment"""
        this = _coin.new_SoTextureCoordinateEnvironment()
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoTextureCoordinateEnvironment self, SoAction action)"""
        return _coin.SoTextureCoordinateEnvironment_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateEnvironment self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateEnvironment_GLRender(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateEnvironment self, SoPickAction action)"""
        return _coin.SoTextureCoordinateEnvironment_pick(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateEnvironment self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateEnvironment_callback(self, action)

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(SoTextureCoordinatePlane self) -> SoType"""
        return _coin.SoTextureCoordinatePlane_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinatePlane_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinatePlane 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, action):
        """doAction(SoTextureCoordinatePlane self, SoAction action)"""
        return _coin.SoTextureCoordinatePlane_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinatePlane self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinatePlane_GLRender(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinatePlane self, SoPickAction action)"""
        return _coin.SoTextureCoordinatePlane_pick(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinatePlane self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinatePlane_callback(self, action)

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(SoTextureMatrixTransform self) -> SoType"""
        return _coin.SoTextureMatrixTransform_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureMatrixTransform_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureMatrixTransform 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, action):
        """doAction(SoTextureMatrixTransform self, SoAction action)"""
        return _coin.SoTextureMatrixTransform_doAction(self, action)


    def callback(self, action):
        """callback(SoTextureMatrixTransform self, SoCallbackAction action)"""
        return _coin.SoTextureMatrixTransform_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureMatrixTransform self, SoGLRenderAction action)"""
        return _coin.SoTextureMatrixTransform_GLRender(self, action)


    def getMatrix(self, action):
        """getMatrix(SoTextureMatrixTransform self, SoGetMatrixAction action)"""
        return _coin.SoTextureMatrixTransform_getMatrix(self, action)


    def pick(self, action):
        """pick(SoTextureMatrixTransform self, SoPickAction action)"""
        return _coin.SoTextureMatrixTransform_pick(self, action)

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(SoWWWInline self) -> SoType"""
        return _coin.SoWWWInline_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoWWWInline_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoWWWInline 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, url):
        """setFullURLName(SoWWWInline self, SbString url)"""
        return _coin.SoWWWInline_setFullURLName(self, url)


    def getFullURLName(self):
        """getFullURLName(SoWWWInline self) -> SbString"""
        return _coin.SoWWWInline_getFullURLName(self)


    def copyChildren(self):
        """copyChildren(SoWWWInline self) -> SoGroup"""
        return _coin.SoWWWInline_copyChildren(self)


    def requestURLData(self):
        """requestURLData(SoWWWInline self)"""
        return _coin.SoWWWInline_requestURLData(self)


    def isURLDataRequested(self):
        """isURLDataRequested(SoWWWInline self) -> SbBool"""
        return _coin.SoWWWInline_isURLDataRequested(self)


    def isURLDataHere(self):
        """isURLDataHere(SoWWWInline self) -> SbBool"""
        return _coin.SoWWWInline_isURLDataHere(self)


    def cancelURLDataRequest(self):
        """cancelURLDataRequest(SoWWWInline self)"""
        return _coin.SoWWWInline_cancelURLDataRequest(self)


    def setChildData(self, urldata):
        """setChildData(SoWWWInline self, SoNode urldata)"""
        return _coin.SoWWWInline_setChildData(self, urldata)


    def getChildData(self):
        """getChildData(SoWWWInline self) -> SoNode"""
        return _coin.SoWWWInline_getChildData(self)


    def getChildren(self):
        """getChildren(SoWWWInline self) -> SoChildList"""
        return _coin.SoWWWInline_getChildren(self)


    def setFetchURLCallBack(f, userdata):
        """setFetchURLCallBack(SoWWWInlineFetchURLCB * f, void * userdata)"""
        return _coin.SoWWWInline_setFetchURLCallBack(f, userdata)

    setFetchURLCallBack = staticmethod(setFetchURLCallBack)

    def setBoundingBoxVisibility(b):
        """setBoundingBoxVisibility(SoWWWInline::BboxVisibility b)"""
        return _coin.SoWWWInline_setBoundingBoxVisibility(b)

    setBoundingBoxVisibility = staticmethod(setBoundingBoxVisibility)

    def getBoundingBoxVisibility():
        """getBoundingBoxVisibility() -> SoWWWInline::BboxVisibility"""
        return _coin.SoWWWInline_getBoundingBoxVisibility()

    getBoundingBoxVisibility = staticmethod(getBoundingBoxVisibility)

    def setBoundingBoxColor(c):
        """setBoundingBoxColor(SbColor c)"""
        return _coin.SoWWWInline_setBoundingBoxColor(c)

    setBoundingBoxColor = staticmethod(setBoundingBoxColor)

    def getBoundingBoxColor():
        """getBoundingBoxColor() -> SbColor"""
        return _coin.SoWWWInline_getBoundingBoxColor()

    getBoundingBoxColor = staticmethod(getBoundingBoxColor)

    def setReadAsSoFile(onoff):
        """setReadAsSoFile(SbBool onoff)"""
        return _coin.SoWWWInline_setReadAsSoFile(onoff)

    setReadAsSoFile = staticmethod(setReadAsSoFile)

    def getReadAsSoFile():
        """getReadAsSoFile() -> SbBool"""
        return _coin.SoWWWInline_getReadAsSoFile()

    getReadAsSoFile = staticmethod(getReadAsSoFile)

    def doAction(self, action):
        """doAction(SoWWWInline self, SoAction action)"""
        return _coin.SoWWWInline_doAction(self, action)


    def doActionOnKidsOrBox(self, action):
        """doActionOnKidsOrBox(SoWWWInline self, SoAction action)"""
        return _coin.SoWWWInline_doActionOnKidsOrBox(self, action)


    def callback(self, action):
        """callback(SoWWWInline self, SoCallbackAction action)"""
        return _coin.SoWWWInline_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoWWWInline self, SoGLRenderAction action)"""
        return _coin.SoWWWInline_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoWWWInline self, SoGetBoundingBoxAction action)"""
        return _coin.SoWWWInline_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoWWWInline self, SoGetMatrixAction action)"""
        return _coin.SoWWWInline_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoWWWInline self, SoHandleEventAction action)"""
        return _coin.SoWWWInline_handleEvent(self, action)


    def search(self, action):
        """search(SoWWWInline self, SoSearchAction action)"""
        return _coin.SoWWWInline_search(self, action)


    def pick(self, action):
        """pick(SoWWWInline self, SoPickAction action)"""
        return _coin.SoWWWInline_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoWWWInline self, SoGetPrimitiveCountAction action)"""
        return _coin.SoWWWInline_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoWWWInline self, SoAudioRenderAction action)"""
        return _coin.SoWWWInline_audioRender(self, action)

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(f, userdata):
    """SoWWWInline_setFetchURLCallBack(SoWWWInlineFetchURLCB * f, void * userdata)"""
    return _coin.SoWWWInline_setFetchURLCallBack(f, userdata)

def SoWWWInline_setBoundingBoxVisibility(b):
    """SoWWWInline_setBoundingBoxVisibility(SoWWWInline::BboxVisibility b)"""
    return _coin.SoWWWInline_setBoundingBoxVisibility(b)

def SoWWWInline_getBoundingBoxVisibility():
    """SoWWWInline_getBoundingBoxVisibility() -> SoWWWInline::BboxVisibility"""
    return _coin.SoWWWInline_getBoundingBoxVisibility()

def SoWWWInline_setBoundingBoxColor(c):
    """SoWWWInline_setBoundingBoxColor(SbColor c)"""
    return _coin.SoWWWInline_setBoundingBoxColor(c)

def SoWWWInline_getBoundingBoxColor():
    """SoWWWInline_getBoundingBoxColor() -> SbColor"""
    return _coin.SoWWWInline_getBoundingBoxColor()

def SoWWWInline_setReadAsSoFile(onoff):
    """SoWWWInline_setReadAsSoFile(SbBool onoff)"""
    return _coin.SoWWWInline_setReadAsSoFile(onoff)

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(SoTransparencyType self) -> SoType"""
        return _coin.SoTransparencyType_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTransparencyType_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTransparencyType 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, action):
        """doAction(SoTransparencyType self, SoAction action)"""
        return _coin.SoTransparencyType_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTransparencyType self, SoGLRenderAction action)"""
        return _coin.SoTransparencyType_GLRender(self, action)


    def callback(self, action):
        """callback(SoTransparencyType self, SoCallbackAction action)"""
        return _coin.SoTransparencyType_callback(self, action)

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(SoTextureCoordinateCube self) -> SoType"""
        return _coin.SoTextureCoordinateCube_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateCube_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateCube self) -> SoTextureCoordinateCube"""
        this = _coin.new_SoTextureCoordinateCube()
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoTextureCoordinateCube self, SoAction action)"""
        return _coin.SoTextureCoordinateCube_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateCube self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateCube_GLRender(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateCube self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateCube_callback(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateCube self, SoPickAction action)"""
        return _coin.SoTextureCoordinateCube_pick(self, action)

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(SoTextureCoordinateSphere self) -> SoType"""
        return _coin.SoTextureCoordinateSphere_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateSphere_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateSphere self) -> SoTextureCoordinateSphere"""
        this = _coin.new_SoTextureCoordinateSphere()
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoTextureCoordinateSphere self, SoAction action)"""
        return _coin.SoTextureCoordinateSphere_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateSphere self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateSphere_GLRender(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateSphere self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateSphere_callback(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateSphere self, SoPickAction action)"""
        return _coin.SoTextureCoordinateSphere_pick(self, action)

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(SoTextureCoordinateCylinder self) -> SoType"""
        return _coin.SoTextureCoordinateCylinder_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateCylinder_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateCylinder self) -> SoTextureCoordinateCylinder"""
        this = _coin.new_SoTextureCoordinateCylinder()
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoTextureCoordinateCylinder self, SoAction action)"""
        return _coin.SoTextureCoordinateCylinder_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateCylinder self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateCylinder_GLRender(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateCylinder self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateCylinder_callback(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateCylinder self, SoPickAction action)"""
        return _coin.SoTextureCoordinateCylinder_pick(self, action)

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(SoTextureCubeMap self) -> SoType"""
        return _coin.SoTextureCubeMap_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCubeMap_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCubeMap 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, action):
        """doAction(SoTextureCubeMap self, SoAction action)"""
        return _coin.SoTextureCubeMap_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCubeMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCubeMap_GLRender(self, action)


    def callback(self, action):
        """callback(SoTextureCubeMap self, SoCallbackAction action)"""
        return _coin.SoTextureCubeMap_callback(self, action)


    def rayPick(self, action):
        """rayPick(SoTextureCubeMap self, SoRayPickAction action)"""
        return _coin.SoTextureCubeMap_rayPick(self, action)


    def readImage(fname, w, h, nc, bytes):
        """readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
        return _coin.SoTextureCubeMap_readImage(fname, w, h, nc, bytes)

    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(fname, w, h, nc, bytes):
    """SoTextureCubeMap_readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
    return _coin.SoTextureCubeMap_readImage(fname, w, h, nc, bytes)

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(SoShaderObject 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, action):
        """GLRender(SoShaderObject self, SoGLRenderAction action)"""
        return _coin.SoShaderObject_GLRender(self, action)


    def search(self, action):
        """search(SoShaderObject self, SoSearchAction action)"""
        return _coin.SoShaderObject_search(self, action)


    def updateParameters(self, state):
        """updateParameters(SoShaderObject self, SoState state)"""
        return _coin.SoShaderObject_updateParameters(self, state)


    def getSourceType(self):
        """getSourceType(SoShaderObject self) -> SoShaderObject::SourceType"""
        return _coin.SoShaderObject_getSourceType(self)


    def getSourceProgram(self):
        """getSourceProgram(SoShaderObject 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(SoShaderParameter 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(SoUniformShaderParameter self) -> SoType"""
        return _coin.SoUniformShaderParameter_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoUniformShaderParameter_initClass()

    initClass = staticmethod(initClass)

    def updateParameter(self, shaderObject):
        """updateParameter(SoUniformShaderParameter self, SoGLShaderObject * shaderObject)"""
        return _coin.SoUniformShaderParameter_updateParameter(self, shaderObject)

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(SoShaderParameter1f self) -> SoType"""
        return _coin.SoShaderParameter1f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter1f_value_get, _coin.SoShaderParameter1f_value_set)

    def __init__(self):
        """__init__(SoShaderParameter1f 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, shaderObject):
        """updateParameter(SoShaderParameter1f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter1f_updateParameter(self, shaderObject)

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(SoShaderParameter1i self) -> SoType"""
        return _coin.SoShaderParameter1i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter1i_value_get, _coin.SoShaderParameter1i_value_set)

    def __init__(self):
        """__init__(SoShaderParameter1i 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, shaderObject):
        """updateParameter(SoShaderParameter1i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter1i_updateParameter(self, shaderObject)

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(SoShaderParameter2f self) -> SoType"""
        return _coin.SoShaderParameter2f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter2f_value_get, _coin.SoShaderParameter2f_value_set)

    def __init__(self):
        """__init__(SoShaderParameter2f 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, shaderObject):
        """updateParameter(SoShaderParameter2f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter2f_updateParameter(self, shaderObject)

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(SoShaderParameter2i self) -> SoType"""
        return _coin.SoShaderParameter2i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter2i_value_get, _coin.SoShaderParameter2i_value_set)

    def __init__(self):
        """__init__(SoShaderParameter2i 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, shaderObject):
        """updateParameter(SoShaderParameter2i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter2i_updateParameter(self, shaderObject)

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(SoShaderParameter3f self) -> SoType"""
        return _coin.SoShaderParameter3f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter3f_value_get, _coin.SoShaderParameter3f_value_set)

    def __init__(self):
        """__init__(SoShaderParameter3f 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, shaderObject):
        """updateParameter(SoShaderParameter3f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter3f_updateParameter(self, shaderObject)

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(SoShaderParameter3i self) -> SoType"""
        return _coin.SoShaderParameter3i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter3i_value_get, _coin.SoShaderParameter3i_value_set)

    def __init__(self):
        """__init__(SoShaderParameter3i 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, shaderObject):
        """updateParameter(SoShaderParameter3i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter3i_updateParameter(self, shaderObject)

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(SoShaderParameter4f self) -> SoType"""
        return _coin.SoShaderParameter4f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter4f_value_get, _coin.SoShaderParameter4f_value_set)

    def __init__(self):
        """__init__(SoShaderParameter4f 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, shaderObject):
        """updateParameter(SoShaderParameter4f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter4f_updateParameter(self, shaderObject)

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(SoShaderParameter4i self) -> SoType"""
        return _coin.SoShaderParameter4i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameter4i_value_get, _coin.SoShaderParameter4i_value_set)

    def __init__(self):
        """__init__(SoShaderParameter4i 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, shaderObject):
        """updateParameter(SoShaderParameter4i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter4i_updateParameter(self, shaderObject)

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(SoShaderParameterArray1f self) -> SoType"""
        return _coin.SoShaderParameterArray1f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray1f_value_get, _coin.SoShaderParameterArray1f_value_set)

    def __init__(self):
        """__init__(SoShaderParameterArray1f 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, shaderObject):
        """updateParameter(SoShaderParameterArray1f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray1f_updateParameter(self, shaderObject)

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(SoShaderParameterArray1i self) -> SoType"""
        return _coin.SoShaderParameterArray1i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray1i_value_get, _coin.SoShaderParameterArray1i_value_set)

    def __init__(self):
        """__init__(SoShaderParameterArray1i 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, shaderObject):
        """updateParameter(SoShaderParameterArray1i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray1i_updateParameter(self, shaderObject)

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(SoShaderParameterArray2f self) -> SoType"""
        return _coin.SoShaderParameterArray2f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray2f_value_get, _coin.SoShaderParameterArray2f_value_set)

    def __init__(self):
        """__init__(SoShaderParameterArray2f 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, shaderObject):
        """updateParameter(SoShaderParameterArray2f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray2f_updateParameter(self, shaderObject)

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(SoShaderParameterArray2i self) -> SoType"""
        return _coin.SoShaderParameterArray2i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray2i_value_get, _coin.SoShaderParameterArray2i_value_set)

    def __init__(self):
        """__init__(SoShaderParameterArray2i 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, shaderObject):
        """updateParameter(SoShaderParameterArray2i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray2i_updateParameter(self, shaderObject)

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(SoShaderParameterArray3f self) -> SoType"""
        return _coin.SoShaderParameterArray3f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray3f_value_get, _coin.SoShaderParameterArray3f_value_set)

    def __init__(self):
        """__init__(SoShaderParameterArray3f 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, shaderObject):
        """updateParameter(SoShaderParameterArray3f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray3f_updateParameter(self, shaderObject)

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(SoShaderParameterArray3i self) -> SoType"""
        return _coin.SoShaderParameterArray3i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray3i_value_get, _coin.SoShaderParameterArray3i_value_set)

    def __init__(self):
        """__init__(SoShaderParameterArray3i 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, shaderObject):
        """updateParameter(SoShaderParameterArray3i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray3i_updateParameter(self, shaderObject)

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(SoShaderParameterArray4f self) -> SoType"""
        return _coin.SoShaderParameterArray4f_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray4f_value_get, _coin.SoShaderParameterArray4f_value_set)

    def __init__(self):
        """__init__(SoShaderParameterArray4f 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, shaderObject):
        """updateParameter(SoShaderParameterArray4f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray4f_updateParameter(self, shaderObject)

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(SoShaderParameterArray4i self) -> SoType"""
        return _coin.SoShaderParameterArray4i_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterArray4i_value_get, _coin.SoShaderParameterArray4i_value_set)

    def __init__(self):
        """__init__(SoShaderParameterArray4i 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, shaderObject):
        """updateParameter(SoShaderParameterArray4i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray4i_updateParameter(self, shaderObject)

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(SoShaderParameterMatrix self) -> SoType"""
        return _coin.SoShaderParameterMatrix_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterMatrix_value_get, _coin.SoShaderParameterMatrix_value_set)

    def __init__(self):
        """__init__(SoShaderParameterMatrix 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, shaderObject):
        """updateParameter(SoShaderParameterMatrix self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterMatrix_updateParameter(self, shaderObject)

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(SoShaderParameterMatrixArray self) -> SoType"""
        return _coin.SoShaderParameterMatrixArray_getTypeId(self)

    value = _swig_property(_coin.SoShaderParameterMatrixArray_value_get, _coin.SoShaderParameterMatrixArray_value_set)

    def __init__(self):
        """__init__(SoShaderParameterMatrixArray 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, shaderObject):
        """updateParameter(SoShaderParameterMatrixArray self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterMatrixArray_updateParameter(self, shaderObject)

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(SoShaderStateMatrixParameter 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__(SoShaderStateMatrixParameter 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, shaderObject):
        """updateParameter(SoShaderStateMatrixParameter self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderStateMatrixParameter_updateParameter(self, shaderObject)

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(SoShaderProgram self) -> SoType"""
        return _coin.SoShaderProgram_getTypeId(self)

    shaderObject = _swig_property(_coin.SoShaderProgram_shaderObject_get, _coin.SoShaderProgram_shaderObject_set)

    def __init__(self):
        """__init__(SoShaderProgram self) -> SoShaderProgram"""
        this = _coin.new_SoShaderProgram()
        try:
            self.this.append(this)
        except:
            self.this = this

    def setEnableCallback(self, cb, closure):
        """setEnableCallback(SoShaderProgram self, SoShaderProgramEnableCB * cb, void * closure)"""
        return _coin.SoShaderProgram_setEnableCallback(self, cb, closure)


    def GLRender(self, action):
        """GLRender(SoShaderProgram self, SoGLRenderAction action)"""
        return _coin.SoShaderProgram_GLRender(self, action)


    def search(self, action):
        """search(SoShaderProgram self, SoSearchAction action)"""
        return _coin.SoShaderProgram_search(self, action)


    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(SoFragmentShader self) -> SoType"""
        return _coin.SoFragmentShader_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoFragmentShader_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoFragmentShader 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(sourceType):
        """isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
        return _coin.SoFragmentShader_isSupported(sourceType)

    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(sourceType):
    """SoFragmentShader_isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
    return _coin.SoFragmentShader_isSupported(sourceType)

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(SoVertexShader self) -> SoType"""
        return _coin.SoVertexShader_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVertexShader_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVertexShader 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(sourceType):
        """isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
        return _coin.SoVertexShader_isSupported(sourceType)

    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(sourceType):
    """SoVertexShader_isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
    return _coin.SoVertexShader_isSupported(sourceType)

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(SoTextureCoordinateNormalMap self) -> SoType"""
        return _coin.SoTextureCoordinateNormalMap_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateNormalMap_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateNormalMap self) -> SoTextureCoordinateNormalMap"""
        this = _coin.new_SoTextureCoordinateNormalMap()
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoTextureCoordinateNormalMap self, SoAction action)"""
        return _coin.SoTextureCoordinateNormalMap_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateNormalMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateNormalMap_GLRender(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateNormalMap self, SoPickAction action)"""
        return _coin.SoTextureCoordinateNormalMap_pick(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateNormalMap self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateNormalMap_callback(self, action)

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(SoTextureCoordinateReflectionMap self) -> SoType"""
        return _coin.SoTextureCoordinateReflectionMap_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateReflectionMap_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateReflectionMap self) -> SoTextureCoordinateReflectionMap"""
        this = _coin.new_SoTextureCoordinateReflectionMap()
        try:
            self.this.append(this)
        except:
            self.this = this

    def doAction(self, action):
        """doAction(SoTextureCoordinateReflectionMap self, SoAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateReflectionMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_GLRender(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateReflectionMap self, SoPickAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_pick(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateReflectionMap self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_callback(self, action)

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(SoTextureCoordinateObject self) -> SoType"""
        return _coin.SoTextureCoordinateObject_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCoordinateObject_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCoordinateObject 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, action):
        """doAction(SoTextureCoordinateObject self, SoAction action)"""
        return _coin.SoTextureCoordinateObject_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCoordinateObject self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateObject_GLRender(self, action)


    def pick(self, action):
        """pick(SoTextureCoordinateObject self, SoPickAction action)"""
        return _coin.SoTextureCoordinateObject_pick(self, action)


    def callback(self, action):
        """callback(SoTextureCoordinateObject self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateObject_callback(self, action)

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(SoTextureScalePolicy self) -> SoType"""
        return _coin.SoTextureScalePolicy_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureScalePolicy_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureScalePolicy 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, action):
        """GLRender(SoTextureScalePolicy self, SoGLRenderAction action)"""
        return _coin.SoTextureScalePolicy_GLRender(self, action)

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(SoTextureUnit self) -> SoType"""
        return _coin.SoTextureUnit_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureUnit_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureUnit 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, action):
        """doAction(SoTextureUnit self, SoAction action)"""
        return _coin.SoTextureUnit_doAction(self, action)


    def callback(self, action):
        """callback(SoTextureUnit self, SoCallbackAction action)"""
        return _coin.SoTextureUnit_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureUnit self, SoGLRenderAction action)"""
        return _coin.SoTextureUnit_GLRender(self, action)


    def pick(self, action):
        """pick(SoTextureUnit self, SoPickAction action)"""
        return _coin.SoTextureUnit_pick(self, action)


    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(SoTextureCombine self) -> SoType"""
        return _coin.SoTextureCombine_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoTextureCombine_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoTextureCombine 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, action):
        """doAction(SoTextureCombine self, SoAction action)"""
        return _coin.SoTextureCombine_doAction(self, action)


    def callback(self, action):
        """callback(SoTextureCombine self, SoCallbackAction action)"""
        return _coin.SoTextureCombine_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoTextureCombine self, SoGLRenderAction action)"""
        return _coin.SoTextureCombine_GLRender(self, action)


    def pick(self, action):
        """pick(SoTextureCombine self, SoPickAction action)"""
        return _coin.SoTextureCombine_pick(self, action)

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(SoSceneTexture2 self) -> SoType"""
        return _coin.SoSceneTexture2_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoSceneTexture2_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSceneTexture2 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, list):
        """notify(SoSceneTexture2 self, SoNotList list)"""
        return _coin.SoSceneTexture2_notify(self, list)


    def write(self, action):
        """write(SoSceneTexture2 self, SoWriteAction action)"""
        return _coin.SoSceneTexture2_write(self, action)


    def doAction(self, action):
        """doAction(SoSceneTexture2 self, SoAction action)"""
        return _coin.SoSceneTexture2_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoSceneTexture2 self, SoGLRenderAction action)"""
        return _coin.SoSceneTexture2_GLRender(self, action)


    def callback(self, action):
        """callback(SoSceneTexture2 self, SoCallbackAction action)"""
        return _coin.SoSceneTexture2_callback(self, action)


    def rayPick(self, action):
        """rayPick(SoSceneTexture2 self, SoRayPickAction action)"""
        return _coin.SoSceneTexture2_rayPick(self, action)

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(SoSceneTextureCubeMap self) -> SoType"""
        return _coin.SoSceneTextureCubeMap_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoSceneTextureCubeMap_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoSceneTextureCubeMap 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, action):
        """doAction(SoSceneTextureCubeMap self, SoAction action)"""
        return _coin.SoSceneTextureCubeMap_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoSceneTextureCubeMap self, SoGLRenderAction action)"""
        return _coin.SoSceneTextureCubeMap_GLRender(self, action)


    def callback(self, action):
        """callback(SoSceneTextureCubeMap self, SoCallbackAction action)"""
        return _coin.SoSceneTextureCubeMap_callback(self, action)


    def rayPick(self, action):
        """rayPick(SoSceneTextureCubeMap self, SoRayPickAction action)"""
        return _coin.SoSceneTextureCubeMap_rayPick(self, action)

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, state):
        """init(SoCacheHintElement self, SoState state)"""
        return _coin.SoCacheHintElement_init(self, state)


    def push(self, state):
        """push(SoCacheHintElement self, SoState state)"""
        return _coin.SoCacheHintElement_push(self, state)


    def pop(self, state, prevtopelement):
        """pop(SoCacheHintElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoCacheHintElement_pop(self, state, prevtopelement)


    def matches(self, element):
        """matches(SoCacheHintElement self, SoElement element) -> SbBool"""
        return _coin.SoCacheHintElement_matches(self, element)


    def copyMatchInfo(self):
        """copyMatchInfo(SoCacheHintElement self) -> SoElement"""
        return _coin.SoCacheHintElement_copyMatchInfo(self)


    def set(state, node, memvalue, gfxvalue):
        """set(SoState state, SoNode node, float const memvalue, float const gfxvalue)"""
        return _coin.SoCacheHintElement_set(state, node, memvalue, gfxvalue)

    set = staticmethod(set)

    def get(state, memvalue, gfxvalue):
        """get(SoState state, float & memvalue, float & gfxvalue)"""
        return _coin.SoCacheHintElement_get(state, memvalue, gfxvalue)

    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(state, node, memvalue, gfxvalue):
    """SoCacheHintElement_set(SoState state, SoNode node, float const memvalue, float const gfxvalue)"""
    return _coin.SoCacheHintElement_set(state, node, memvalue, gfxvalue)

def SoCacheHintElement_get(state, memvalue, gfxvalue):
    """SoCacheHintElement_get(SoState state, float & memvalue, float & gfxvalue)"""
    return _coin.SoCacheHintElement_get(state, memvalue, gfxvalue)

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(SoCacheHint self) -> SoType"""
        return _coin.SoCacheHint_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoCacheHint_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoCacheHint 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, action):
        """doAction(SoCacheHint self, SoAction action)"""
        return _coin.SoCacheHint_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoCacheHint self, SoGLRenderAction action)"""
        return _coin.SoCacheHint_GLRender(self, action)


    def callback(self, action):
        """callback(SoCacheHint self, SoCallbackAction action)"""
        return _coin.SoCacheHint_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoCacheHint self, SoGetBoundingBoxAction action)"""
        return _coin.SoCacheHint_getBoundingBox(self, action)


    def pick(self, action):
        """pick(SoCacheHint self, SoPickAction action)"""
        return _coin.SoCacheHint_pick(self, action)

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(SoDepthBuffer self) -> SoType"""
        return _coin.SoDepthBuffer_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoDepthBuffer_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoDepthBuffer 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, action):
        """GLRender(SoDepthBuffer self, SoGLRenderAction action)"""
        return _coin.SoDepthBuffer_GLRender(self, action)

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__(SbLine self) -> SbLine
        __init__(SbLine self, SbVec3f origin, SbVec3f point) -> SbLine
        """
        this = _coin.new_SbLine(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, origin, point):
        """setValue(SbLine self, SbVec3f origin, SbVec3f point)"""
        return _coin.SbLine_setValue(self, origin, point)


    def getClosestPoints(self, line2, ptOnThis, ptOnLine2):
        """getClosestPoints(SbLine self, SbLine line2, SbVec3f ptOnThis, SbVec3f ptOnLine2) -> SbBool"""
        return _coin.SbLine_getClosestPoints(self, line2, ptOnThis, ptOnLine2)


    def getClosestPoint(self, point):
        """getClosestPoint(SbLine self, SbVec3f point) -> SbVec3f"""
        return _coin.SbLine_getClosestPoint(self, point)


    def getPosition(self):
        """getPosition(SbLine self) -> SbVec3f"""
        return _coin.SbLine_getPosition(self)


    def getDirection(self):
        """getDirection(SbLine self) -> SbVec3f"""
        return _coin.SbLine_getDirection(self)


    def output(self, file):
        """output(SbLine self, FILE * file)"""
        return _coin.SbLine_output(self, file)

    __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, point):
        """project(SbProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbProjector_project(self, point)


    def setViewVolume(self, vol):
        """setViewVolume(SbProjector self, SbViewVolume vol)"""
        return _coin.SbProjector_setViewVolume(self, vol)


    def getViewVolume(self):
        """getViewVolume(SbProjector self) -> SbViewVolume"""
        return _coin.SbProjector_getViewVolume(self)


    def setWorkingSpace(self, space):
        """setWorkingSpace(SbProjector self, SbMatrix space)"""
        return _coin.SbProjector_setWorkingSpace(self, space)


    def getWorkingSpace(self):
        """getWorkingSpace(SbProjector self) -> SbMatrix"""
        return _coin.SbProjector_getWorkingSpace(self)


    def copy(self):
        """copy(SbProjector self) -> SbProjector"""
        return _coin.SbProjector_copy(self)


    def tryProject(self, point, epsilon, result):
        """tryProject(SbProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbProjector_tryProject(self, point, epsilon, result)

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__(SbCylinder self) -> SbCylinder
        __init__(SbCylinder self, SbLine a, float const r) -> SbCylinder
        """
        this = _coin.new_SbCylinder(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, a, r):
        """setValue(SbCylinder self, SbLine a, float const r)"""
        return _coin.SbCylinder_setValue(self, a, r)


    def setAxis(self, a):
        """setAxis(SbCylinder self, SbLine a)"""
        return _coin.SbCylinder_setAxis(self, a)


    def setRadius(self, r):
        """setRadius(SbCylinder self, float const r)"""
        return _coin.SbCylinder_setRadius(self, r)


    def getAxis(self):
        """getAxis(SbCylinder self) -> SbLine"""
        return _coin.SbCylinder_getAxis(self)


    def getRadius(self):
        """getRadius(SbCylinder self) -> float"""
        return _coin.SbCylinder_getRadius(self)


    def intersect(self, *args):
        """
        intersect(SbCylinder self, SbLine l, SbVec3f intersection) -> SbBool
        intersect(SbCylinder self, SbLine l, SbVec3f enter, SbVec3f exit) -> SbBool
        """
        return _coin.SbCylinder_intersect(self, *args)


    def output(self, file):
        """output(SbCylinder self, FILE * file)"""
        return _coin.SbCylinder_output(self, file)

    __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, point):
        """project(SbCylinderProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderProjector_project(self, point)


    def projectAndGetRotation(self, point, rot):
        """projectAndGetRotation(SbCylinderProjector self, SbVec2f point, SbRotation rot) -> SbVec3f"""
        return _coin.SbCylinderProjector_projectAndGetRotation(self, point, rot)


    def getRotation(self, point1, point2):
        """getRotation(SbCylinderProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderProjector_getRotation(self, point1, point2)


    def setCylinder(self, cyl):
        """setCylinder(SbCylinderProjector self, SbCylinder cyl)"""
        return _coin.SbCylinderProjector_setCylinder(self, cyl)


    def getCylinder(self):
        """getCylinder(SbCylinderProjector self) -> SbCylinder"""
        return _coin.SbCylinderProjector_getCylinder(self)


    def setOrientToEye(self, orienttoeye):
        """setOrientToEye(SbCylinderProjector self, SbBool const orienttoeye)"""
        return _coin.SbCylinderProjector_setOrientToEye(self, orienttoeye)


    def isOrientToEye(self):
        """isOrientToEye(SbCylinderProjector self) -> SbBool"""
        return _coin.SbCylinderProjector_isOrientToEye(self)


    def setFront(self, infront):
        """setFront(SbCylinderProjector self, SbBool const infront)"""
        return _coin.SbCylinderProjector_setFront(self, infront)


    def isFront(self):
        """isFront(SbCylinderProjector self) -> SbBool"""
        return _coin.SbCylinderProjector_isFront(self)


    def isPointInFront(self, point):
        """isPointInFront(SbCylinderProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbCylinderProjector_isPointInFront(self, point)


    def setWorkingSpace(self, space):
        """setWorkingSpace(SbCylinderProjector self, SbMatrix space)"""
        return _coin.SbCylinderProjector_setWorkingSpace(self, space)

    __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__(SbCylinderSectionProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderSectionProjector
        __init__(SbCylinderSectionProjector self, float const edgetol=0.9) -> SbCylinderSectionProjector
        __init__(SbCylinderSectionProjector self) -> SbCylinderSectionProjector
        __init__(SbCylinderSectionProjector self, SbCylinder cyl, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderSectionProjector
        __init__(SbCylinderSectionProjector self, SbCylinder cyl, float const edgetol=0.9) -> SbCylinderSectionProjector
        __init__(SbCylinderSectionProjector self, SbCylinder cyl) -> SbCylinderSectionProjector
        """
        this = _coin.new_SbCylinderSectionProjector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def copy(self):
        """copy(SbCylinderSectionProjector self) -> SbProjector"""
        return _coin.SbCylinderSectionProjector_copy(self)


    def project(self, point):
        """project(SbCylinderSectionProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderSectionProjector_project(self, point)


    def getRotation(self, point1, point2):
        """getRotation(SbCylinderSectionProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderSectionProjector_getRotation(self, point1, point2)


    def setTolerance(self, edgetol):
        """setTolerance(SbCylinderSectionProjector self, float const edgetol)"""
        return _coin.SbCylinderSectionProjector_setTolerance(self, edgetol)


    def getTolerance(self):
        """getTolerance(SbCylinderSectionProjector self) -> float"""
        return _coin.SbCylinderSectionProjector_getTolerance(self)


    def isWithinTolerance(self, point):
        """isWithinTolerance(SbCylinderSectionProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbCylinderSectionProjector_isWithinTolerance(self, point)

    __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__(SbCylinderPlaneProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderPlaneProjector
        __init__(SbCylinderPlaneProjector self, float const edgetol=0.9) -> SbCylinderPlaneProjector
        __init__(SbCylinderPlaneProjector self) -> SbCylinderPlaneProjector
        __init__(SbCylinderPlaneProjector self, SbCylinder cyl, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderPlaneProjector
        __init__(SbCylinderPlaneProjector self, SbCylinder cyl, float const edgetol=0.9) -> SbCylinderPlaneProjector
        __init__(SbCylinderPlaneProjector self, SbCylinder cyl) -> SbCylinderPlaneProjector
        """
        this = _coin.new_SbCylinderPlaneProjector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def copy(self):
        """copy(SbCylinderPlaneProjector self) -> SbProjector"""
        return _coin.SbCylinderPlaneProjector_copy(self)


    def project(self, point):
        """project(SbCylinderPlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderPlaneProjector_project(self, point)


    def getRotation(self, point1, point2):
        """getRotation(SbCylinderPlaneProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderPlaneProjector_getRotation(self, point1, point2)

    __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__(SbCylinderSheetProjector self, SbBool const orienttoeye=1) -> SbCylinderSheetProjector
        __init__(SbCylinderSheetProjector self) -> SbCylinderSheetProjector
        __init__(SbCylinderSheetProjector self, SbCylinder cyl, SbBool const orienttoeye=1) -> SbCylinderSheetProjector
        __init__(SbCylinderSheetProjector self, SbCylinder cyl) -> SbCylinderSheetProjector
        """
        this = _coin.new_SbCylinderSheetProjector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def copy(self):
        """copy(SbCylinderSheetProjector self) -> SbProjector"""
        return _coin.SbCylinderSheetProjector_copy(self)


    def project(self, point):
        """project(SbCylinderSheetProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderSheetProjector_project(self, point)


    def getRotation(self, point1, point2):
        """getRotation(SbCylinderSheetProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderSheetProjector_getRotation(self, point1, point2)

    __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__(SbLineProjector self) -> SbLineProjector"""
        this = _coin.new_SbLineProjector()
        try:
            self.this.append(this)
        except:
            self.this = this

    def copy(self):
        """copy(SbLineProjector self) -> SbProjector"""
        return _coin.SbLineProjector_copy(self)


    def project(self, point):
        """project(SbLineProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbLineProjector_project(self, point)


    def tryProject(self, point, epsilon, result):
        """tryProject(SbLineProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbLineProjector_tryProject(self, point, epsilon, result)


    def setLine(self, line):
        """setLine(SbLineProjector self, SbLine line)"""
        return _coin.SbLineProjector_setLine(self, line)


    def getLine(self):
        """getLine(SbLineProjector self) -> SbLine"""
        return _coin.SbLineProjector_getLine(self)


    def getVector(self, *args):
        """
        getVector(SbLineProjector self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f
        getVector(SbLineProjector self, SbVec2f viewpos) -> SbVec3f
        """
        return _coin.SbLineProjector_getVector(self, *args)


    def setStartPosition(self, *args):
        """
        setStartPosition(SbLineProjector self, SbVec2f viewpos)
        setStartPosition(SbLineProjector 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__(SbPlaneProjector self, SbBool const orient=0) -> SbPlaneProjector
        __init__(SbPlaneProjector self) -> SbPlaneProjector
        __init__(SbPlaneProjector self, SbPlane plane, SbBool const orient=0) -> SbPlaneProjector
        __init__(SbPlaneProjector self, SbPlane plane) -> SbPlaneProjector
        """
        this = _coin.new_SbPlaneProjector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def copy(self):
        """copy(SbPlaneProjector self) -> SbProjector"""
        return _coin.SbPlaneProjector_copy(self)


    def project(self, point):
        """project(SbPlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbPlaneProjector_project(self, point)


    def tryProject(self, point, epsilon, result):
        """tryProject(SbPlaneProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbPlaneProjector_tryProject(self, point, epsilon, result)


    def setPlane(self, plane):
        """setPlane(SbPlaneProjector self, SbPlane plane)"""
        return _coin.SbPlaneProjector_setPlane(self, plane)


    def getPlane(self):
        """getPlane(SbPlaneProjector self) -> SbPlane"""
        return _coin.SbPlaneProjector_getPlane(self)


    def setOrientToEye(self, orienttoeye):
        """setOrientToEye(SbPlaneProjector self, SbBool const orienttoeye)"""
        return _coin.SbPlaneProjector_setOrientToEye(self, orienttoeye)


    def isOrientToEye(self):
        """isOrientToEye(SbPlaneProjector self) -> SbBool"""
        return _coin.SbPlaneProjector_isOrientToEye(self)


    def getVector(self, *args):
        """
        getVector(SbPlaneProjector self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f
        getVector(SbPlaneProjector self, SbVec2f viewpos) -> SbVec3f
        """
        return _coin.SbPlaneProjector_getVector(self, *args)


    def setStartPosition(self, *args):
        """
        setStartPosition(SbPlaneProjector self, SbVec2f viewpos)
        setStartPosition(SbPlaneProjector 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__(SbSphere self) -> SbSphere
        __init__(SbSphere self, SbVec3f center, float const radius) -> SbSphere
        """
        this = _coin.new_SbSphere(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, center, radius):
        """setValue(SbSphere self, SbVec3f center, float const radius)"""
        return _coin.SbSphere_setValue(self, center, radius)


    def setCenter(self, center):
        """setCenter(SbSphere self, SbVec3f center)"""
        return _coin.SbSphere_setCenter(self, center)


    def setRadius(self, radius):
        """setRadius(SbSphere self, float const radius)"""
        return _coin.SbSphere_setRadius(self, radius)


    def getCenter(self):
        """getCenter(SbSphere self) -> SbVec3f"""
        return _coin.SbSphere_getCenter(self)


    def getRadius(self):
        """getRadius(SbSphere self) -> float"""
        return _coin.SbSphere_getRadius(self)


    def circumscribe(self, box):
        """circumscribe(SbSphere self, SbBox3f box)"""
        return _coin.SbSphere_circumscribe(self, box)


    def intersect(self, *args):
        """
        intersect(SbSphere self, SbLine l, SbVec3f intersection) -> SbBool
        intersect(SbSphere self, SbLine l, SbVec3f enter, SbVec3f exit) -> SbBool
        """
        return _coin.SbSphere_intersect(self, *args)


    def pointInside(self, p):
        """pointInside(SbSphere self, SbVec3f p) -> SbBool"""
        return _coin.SbSphere_pointInside(self, p)


    def output(self, file):
        """output(SbSphere self, FILE * file)"""
        return _coin.SbSphere_output(self, file)

    __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, point, rot):
        """projectAndGetRotation(SbSphereProjector self, SbVec2f point, SbRotation rot) -> SbVec3f"""
        return _coin.SbSphereProjector_projectAndGetRotation(self, point, rot)


    def getRotation(self, point1, point2):
        """getRotation(SbSphereProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereProjector_getRotation(self, point1, point2)


    def setSphere(self, sph):
        """setSphere(SbSphereProjector self, SbSphere sph)"""
        return _coin.SbSphereProjector_setSphere(self, sph)


    def getSphere(self):
        """getSphere(SbSphereProjector self) -> SbSphere"""
        return _coin.SbSphereProjector_getSphere(self)


    def setOrientToEye(self, orienttoeye):
        """setOrientToEye(SbSphereProjector self, SbBool const orienttoeye)"""
        return _coin.SbSphereProjector_setOrientToEye(self, orienttoeye)


    def isOrientToEye(self):
        """isOrientToEye(SbSphereProjector self) -> SbBool"""
        return _coin.SbSphereProjector_isOrientToEye(self)


    def setFront(self, infront):
        """setFront(SbSphereProjector self, SbBool const infront)"""
        return _coin.SbSphereProjector_setFront(self, infront)


    def isFront(self):
        """isFront(SbSphereProjector self) -> SbBool"""
        return _coin.SbSphereProjector_isFront(self)


    def isPointInFront(self, point):
        """isPointInFront(SbSphereProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbSphereProjector_isPointInFront(self, point)


    def setWorkingSpace(self, space):
        """setWorkingSpace(SbSphereProjector self, SbMatrix space)"""
        return _coin.SbSphereProjector_setWorkingSpace(self, space)

    __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__(SbSphereSheetProjector self, SbBool const orienttoeye=1) -> SbSphereSheetProjector
        __init__(SbSphereSheetProjector self) -> SbSphereSheetProjector
        __init__(SbSphereSheetProjector self, SbSphere sph, SbBool const orienttoeye=1) -> SbSphereSheetProjector
        __init__(SbSphereSheetProjector self, SbSphere sph) -> SbSphereSheetProjector
        """
        this = _coin.new_SbSphereSheetProjector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def copy(self):
        """copy(SbSphereSheetProjector self) -> SbProjector"""
        return _coin.SbSphereSheetProjector_copy(self)


    def project(self, point):
        """project(SbSphereSheetProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSphereSheetProjector_project(self, point)


    def getRotation(self, point1, point2):
        """getRotation(SbSphereSheetProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereSheetProjector_getRotation(self, point1, point2)

    __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__(SbSphereSectionProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSphereSectionProjector
        __init__(SbSphereSectionProjector self, float const edgetol=0.9) -> SbSphereSectionProjector
        __init__(SbSphereSectionProjector self) -> SbSphereSectionProjector
        __init__(SbSphereSectionProjector self, SbSphere sph, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSphereSectionProjector
        __init__(SbSphereSectionProjector self, SbSphere sph, float const edgetol=0.9) -> SbSphereSectionProjector
        __init__(SbSphereSectionProjector self, SbSphere sph) -> SbSphereSectionProjector
        """
        this = _coin.new_SbSphereSectionProjector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def copy(self):
        """copy(SbSphereSectionProjector self) -> SbProjector"""
        return _coin.SbSphereSectionProjector_copy(self)


    def project(self, point):
        """project(SbSphereSectionProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSphereSectionProjector_project(self, point)


    def getRotation(self, point1, point2):
        """getRotation(SbSphereSectionProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereSectionProjector_getRotation(self, point1, point2)


    def setTolerance(self, edgetol):
        """setTolerance(SbSphereSectionProjector self, float const edgetol)"""
        return _coin.SbSphereSectionProjector_setTolerance(self, edgetol)


    def getTolerance(self):
        """getTolerance(SbSphereSectionProjector self) -> float"""
        return _coin.SbSphereSectionProjector_getTolerance(self)


    def setRadialFactor(self, rad=0.0):
        """
        setRadialFactor(SbSphereSectionProjector self, float const rad=0.0)
        setRadialFactor(SbSphereSectionProjector self)
        """
        return _coin.SbSphereSectionProjector_setRadialFactor(self, rad)


    def getRadialFactor(self):
        """getRadialFactor(SbSphereSectionProjector self) -> float"""
        return _coin.SbSphereSectionProjector_getRadialFactor(self)


    def isWithinTolerance(self, point):
        """isWithinTolerance(SbSphereSectionProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbSphereSectionProjector_isWithinTolerance(self, point)

    __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__(SbSpherePlaneProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSpherePlaneProjector
        __init__(SbSpherePlaneProjector self, float const edgetol=0.9) -> SbSpherePlaneProjector
        __init__(SbSpherePlaneProjector self) -> SbSpherePlaneProjector
        __init__(SbSpherePlaneProjector self, SbSphere sph, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSpherePlaneProjector
        __init__(SbSpherePlaneProjector self, SbSphere sph, float const edgetol=0.9) -> SbSpherePlaneProjector
        __init__(SbSpherePlaneProjector self, SbSphere sph) -> SbSpherePlaneProjector
        """
        this = _coin.new_SbSpherePlaneProjector(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def copy(self):
        """copy(SbSpherePlaneProjector self) -> SbProjector"""
        return _coin.SbSpherePlaneProjector_copy(self)


    def project(self, point):
        """project(SbSpherePlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSpherePlaneProjector_project(self, point)


    def getRotation(self, point1, point2):
        """getRotation(SbSpherePlaneProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSpherePlaneProjector_getRotation(self, point1, point2)

    __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__(SbClip self, SbClipCallback * callback=None, void * userdata=None) -> SbClip
        __init__(SbClip self, SbClipCallback * callback=None) -> SbClip
        __init__(SbClip self) -> SbClip
        """
        this = _coin.new_SbClip(callback, userdata)
        try:
            self.this.append(this)
        except:
            self.this = this

    def addVertex(self, v, vdata=None):
        """
        addVertex(SbClip self, SbVec3f v, void * vdata=None)
        addVertex(SbClip self, SbVec3f v)
        """
        return _coin.SbClip_addVertex(self, v, vdata)


    def reset(self):
        """reset(SbClip self)"""
        return _coin.SbClip_reset(self)


    def clip(self, plane):
        """clip(SbClip self, SbPlane plane)"""
        return _coin.SbClip_clip(self, plane)


    def getNumVertices(self):
        """getNumVertices(SbClip self) -> int"""
        return _coin.SbClip_getNumVertices(self)


    def getVertex(self, idx, v, vdata=None):
        """
        getVertex(SbClip self, int const idx, SbVec3f v, void ** vdata=None)
        getVertex(SbClip self, int const idx, SbVec3f v)
        """
        return _coin.SbClip_getVertex(self, idx, v, vdata)


    def getVertexData(self, idx):
        """getVertexData(SbClip self, int const idx) -> void *"""
        return _coin.SbClip_getVertexData(self, idx)

    __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__(SbDPRotation self) -> SbDPRotation
        __init__(SbDPRotation self, SbVec3d axis, double const radians) -> SbDPRotation
        __init__(SbDPRotation self, double const [4] q) -> SbDPRotation
        __init__(SbDPRotation self, double const q0, double const q1, double const q2, double const q3) -> SbDPRotation
        __init__(SbDPRotation self, SbDPMatrix m) -> SbDPRotation
        __init__(SbDPRotation self, SbVec3d rotateFrom, SbVec3d rotateTo) -> SbDPRotation
        """
        this = _coin.new_SbDPRotation(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def getValue(self):
        """getValue(SbDPRotation self) -> double const *"""
        return _coin.SbDPRotation_getValue(self)


    def getAxisAngle(self):
        """getAxisAngle(SbDPRotation self)"""
        return _coin.SbDPRotation_getAxisAngle(self)


    def getMatrix(self):
        """getMatrix(SbDPRotation self)"""
        return _coin.SbDPRotation_getMatrix(self)


    def invert(self):
        """invert(SbDPRotation self) -> SbDPRotation"""
        return _coin.SbDPRotation_invert(self)


    def inverse(self):
        """inverse(SbDPRotation self) -> SbDPRotation"""
        return _coin.SbDPRotation_inverse(self)


    def setValue(self, *args):
        """
        setValue(SbDPRotation self, double const q0, double const q1, double const q2, double const q3) -> SbDPRotation
        setValue(SbDPRotation self, double const [4] q) -> SbDPRotation
        setValue(SbDPRotation self, SbDPMatrix m) -> SbDPRotation
        setValue(SbDPRotation self, SbVec3d axis, double const radians) -> SbDPRotation
        setValue(SbDPRotation self, SbVec3d rotateFrom, SbVec3d rotateTo) -> SbDPRotation
        """
        return _coin.SbDPRotation_setValue(self, *args)


    def __imul__(self, *args):
        """
        __imul__(SbDPRotation self, SbDPRotation q) -> SbDPRotation
        __imul__(SbDPRotation self, double const s) -> SbDPRotation
        """
        return _coin.SbDPRotation___imul__(self, *args)


    def equals(self, r, tolerance):
        """equals(SbDPRotation self, SbDPRotation r, double const tolerance) -> SbBool"""
        return _coin.SbDPRotation_equals(self, r, tolerance)


    def multVec(self, src, dst):
        """multVec(SbDPRotation self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPRotation_multVec(self, src, dst)


    def scaleAngle(self, scaleFactor):
        """scaleAngle(SbDPRotation self, double const scaleFactor)"""
        return _coin.SbDPRotation_scaleAngle(self, scaleFactor)


    def slerp(rot0, rot1, t):
        """slerp(SbDPRotation rot0, SbDPRotation rot1, double t) -> SbDPRotation"""
        return _coin.SbDPRotation_slerp(rot0, rot1, t)

    slerp = staticmethod(slerp)

    def identity():
        """identity() -> SbDPRotation"""
        return _coin.SbDPRotation_identity()

    identity = staticmethod(identity)

    def output(self, fp):
        """output(SbDPRotation self, FILE * fp)"""
        return _coin.SbDPRotation_output(self, fp)


    def __mul__(self, *args):
        """
        __mul__(SbDPRotation self, SbDPRotation u) -> SbDPRotation
        __mul__(SbDPRotation self, double const d) -> SbDPRotation
        __mul__(SbDPRotation self, SbVec3d v) -> SbVec3d
        """
        return _coin.SbDPRotation___mul__(self, *args)


    def __eq__(self, u):
        """__eq__(SbDPRotation self, SbDPRotation u) -> int"""
        return _coin.SbDPRotation___eq__(self, u)


    def __nq__(self, u):
        """__nq__(SbDPRotation self, SbDPRotation u) -> int"""
        return _coin.SbDPRotation___nq__(self, u)

    __swig_destroy__ = _coin.delete_SbDPRotation
    __del__ = lambda self: None
SbDPRotation_swigregister = _coin.SbDPRotation_swigregister
SbDPRotation_swigregister(SbDPRotation)

def SbDPRotation_slerp(rot0, rot1, t):
    """SbDPRotation_slerp(SbDPRotation rot0, SbDPRotation rot1, double t) -> SbDPRotation"""
    return _coin.SbDPRotation_slerp(rot0, rot1, t)

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__(SbDPMatrix self) -> SbDPMatrix
        __init__(SbDPMatrix self, double const a11, double const a12, double const a13, double const a14, double const a21, double const a22, double const a23, double const a24, double const a31, double const a32, double const a33, double const a34, double const a41, double const a42, double const a43, double const a44) -> SbDPMatrix
        __init__(SbDPMatrix self, SbDPMat const & matrix) -> SbDPMatrix
        __init__(SbDPMatrix self, SbDPMat const * matrix) -> SbDPMatrix
        __init__(SbDPMatrix 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, m):
        """setValue(SbDPMatrix self, SbDPMat const & m)"""
        return _coin.SbDPMatrix_setValue(self, m)


    def makeIdentity(self):
        """makeIdentity(SbDPMatrix self)"""
        return _coin.SbDPMatrix_makeIdentity(self)


    def setRotate(self, q):
        """setRotate(SbDPMatrix self, SbDPRotation q)"""
        return _coin.SbDPMatrix_setRotate(self, q)


    def inverse(self):
        """inverse(SbDPMatrix self) -> SbDPMatrix"""
        return _coin.SbDPMatrix_inverse(self)


    def det3(self, *args):
        """
        det3(SbDPMatrix self, int r1, int r2, int r3, int c1, int c2, int c3) -> double
        det3(SbDPMatrix self) -> double
        """
        return _coin.SbDPMatrix_det3(self, *args)


    def det4(self):
        """det4(SbDPMatrix self) -> double"""
        return _coin.SbDPMatrix_det4(self)


    def equals(self, m, tolerance):
        """equals(SbDPMatrix self, SbDPMatrix m, double tolerance) -> SbBool"""
        return _coin.SbDPMatrix_equals(self, m, tolerance)


    def __imul__(self, m):
        """__imul__(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix___imul__(self, m)


    def getValue(self, *args):
        """
        getValue(SbDPMatrix self) -> SbDPMat const
        getValue(SbDPMatrix 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(SbDPMatrix self, double const s)
        setScale(SbDPMatrix self, SbVec3d s)
        """
        return _coin.SbDPMatrix_setScale(self, *args)


    def setTranslate(self, t):
        """setTranslate(SbDPMatrix self, SbVec3d t)"""
        return _coin.SbDPMatrix_setTranslate(self, t)


    def setTransform(self, *args):
        """
        setTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s)
        setTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s, SbDPRotation so)
        setTransform(SbDPMatrix self, SbVec3d translation, SbDPRotation rotation, SbVec3d scaleFactor, SbDPRotation scaleOrientation, SbVec3d center)
        """
        return _coin.SbDPMatrix_setTransform(self, *args)


    def getTransform(self, *args):
        """
        getTransform(SbDPMatrix self, SbVec3d t, SbDPRotation r, SbVec3d s, SbDPRotation so)
        getTransform(SbDPMatrix self, SbVec3d translation, SbDPRotation rotation, SbVec3d scaleFactor, SbDPRotation scaleOrientation, SbVec3d center)
        """
        return _coin.SbDPMatrix_getTransform(self, *args)


    def factor(self, r, s, u, t, proj):
        """factor(SbDPMatrix self, SbDPMatrix r, SbVec3d s, SbDPMatrix u, SbVec3d t, SbDPMatrix proj) -> SbBool"""
        return _coin.SbDPMatrix_factor(self, r, s, u, t, proj)


    def LUDecomposition(self, index, d):
        """LUDecomposition(SbDPMatrix self, int [4] index, double & d) -> SbBool"""
        return _coin.SbDPMatrix_LUDecomposition(self, index, d)


    def LUBackSubstitution(self, index, b):
        """LUBackSubstitution(SbDPMatrix self, int [4] index, double [4] b)"""
        return _coin.SbDPMatrix_LUBackSubstitution(self, index, b)


    def transpose(self):
        """transpose(SbDPMatrix self) -> SbDPMatrix"""
        return _coin.SbDPMatrix_transpose(self)


    def multRight(self, m):
        """multRight(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix_multRight(self, m)


    def multLeft(self, m):
        """multLeft(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix_multLeft(self, m)


    def multMatrixVec(self, src, dst):
        """multMatrixVec(SbDPMatrix self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPMatrix_multMatrixVec(self, src, dst)


    def multDirMatrix(self, src, dst):
        """multDirMatrix(SbDPMatrix self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPMatrix_multDirMatrix(self, src, dst)


    def multLineMatrix(self, src, dst):
        """multLineMatrix(SbDPMatrix self, SbDPLine src, SbDPLine dst)"""
        return _coin.SbDPMatrix_multLineMatrix(self, src, dst)


    def multVecMatrix(self, *args):
        """
        multVecMatrix(SbDPMatrix self, SbVec3d src, SbVec3d dst)
        multVecMatrix(SbDPMatrix self, SbVec4d src, SbVec4d dst)
        """
        return _coin.SbDPMatrix_multVecMatrix(self, *args)


    def output(self, fp):
        """output(SbDPMatrix self, FILE * fp)"""
        return _coin.SbDPMatrix_output(self, fp)


    def __mul__(self, *args):
        """
        __mul__(SbDPMatrix self, SbDPMatrix u) -> SbDPMatrix
        __mul__(SbDPMatrix self, SbVec3d u) -> SbVec3d
        """
        return _coin.SbDPMatrix___mul__(self, *args)


    def __rmul__(self, u):
        """__rmul__(SbDPMatrix self, SbVec3d u) -> SbVec3d"""
        return _coin.SbDPMatrix___rmul__(self, u)


    def __eq__(self, u):
        """__eq__(SbDPMatrix self, SbDPMatrix u) -> int"""
        return _coin.SbDPMatrix___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbDPMatrix self, SbDPMatrix u) -> int"""
        return _coin.SbDPMatrix___ne__(self, u)

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__(SbDPLine self) -> SbDPLine
        __init__(SbDPLine self, SbVec3d p0, SbVec3d p1) -> SbDPLine
        """
        this = _coin.new_SbDPLine(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def setValue(self, p0, p1):
        """setValue(SbDPLine self, SbVec3d p0, SbVec3d p1)"""
        return _coin.SbDPLine_setValue(self, p0, p1)


    def getClosestPoints(self, line2, ptOnThis, ptOnLine2):
        """getClosestPoints(SbDPLine self, SbDPLine line2, SbVec3d ptOnThis, SbVec3d ptOnLine2) -> SbBool"""
        return _coin.SbDPLine_getClosestPoints(self, line2, ptOnThis, ptOnLine2)


    def getClosestPoint(self, point):
        """getClosestPoint(SbDPLine self, SbVec3d point) -> SbVec3d"""
        return _coin.SbDPLine_getClosestPoint(self, point)


    def getPosition(self):
        """getPosition(SbDPLine self) -> SbVec3d"""
        return _coin.SbDPLine_getPosition(self)


    def getDirection(self):
        """getDirection(SbDPLine self) -> SbVec3d"""
        return _coin.SbDPLine_getDirection(self)


    def output(self, file):
        """output(SbDPLine self, FILE * file)"""
        return _coin.SbDPLine_output(self, file)

    __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__(SbDPPlane self) -> SbDPPlane
        __init__(SbDPPlane self, SbVec3d normal, double const D) -> SbDPPlane
        __init__(SbDPPlane self, SbVec3d p0, SbVec3d p1, SbVec3d p2) -> SbDPPlane
        __init__(SbDPPlane self, SbVec3d normal, SbVec3d point) -> SbDPPlane
        """
        this = _coin.new_SbDPPlane(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def offset(self, d):
        """offset(SbDPPlane self, double const d)"""
        return _coin.SbDPPlane_offset(self, d)


    def transform(self):
        """transform(SbDPPlane self)"""
        return _coin.SbDPPlane_transform(self)


    def isInHalfSpace(self, point):
        """isInHalfSpace(SbDPPlane self, SbVec3d point) -> SbBool"""
        return _coin.SbDPPlane_isInHalfSpace(self, point)


    def getDistance(self, point):
        """getDistance(SbDPPlane self, SbVec3d point) -> double"""
        return _coin.SbDPPlane_getDistance(self, point)


    def getNormal(self):
        """getNormal(SbDPPlane self) -> SbVec3d"""
        return _coin.SbDPPlane_getNormal(self)


    def getDistanceFromOrigin(self):
        """getDistanceFromOrigin(SbDPPlane self) -> double"""
        return _coin.SbDPPlane_getDistanceFromOrigin(self)


    def output(self, file):
        """output(SbDPPlane self, FILE * file)"""
        return _coin.SbDPPlane_output(self, file)


    def intersect(self, *args):
        """
        intersect(SbDPPlane self, SbDPLine l, SbVec3d intersection) -> SbBool
        intersect(SbDPPlane self, SbDPPlane pl, SbDPLine line) -> SbBool
        """
        return _coin.SbDPPlane_intersect(self, *args)


    def __eq__(self, u):
        """__eq__(SbDPPlane self, SbDPPlane u) -> int"""
        return _coin.SbDPPlane___eq__(self, u)


    def __ne__(self, u):
        """__ne__(SbDPPlane self, SbDPPlane u) -> int"""
        return _coin.SbDPPlane___ne__(self, u)

    __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__(SbHeapFuncs 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, SbHeapFuncs, initsize=1024):
        """
        __init__(SbHeap self, SbHeapFuncs SbHeapFuncs, int const initsize=1024) -> SbHeap
        __init__(SbHeap self, SbHeapFuncs SbHeapFuncs) -> SbHeap
        """
        this = _coin.new_SbHeap(SbHeapFuncs, initsize)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SbHeap
    __del__ = lambda self: None

    def emptyHeap(self):
        """emptyHeap(SbHeap self)"""
        return _coin.SbHeap_emptyHeap(self)


    def size(self):
        """size(SbHeap self) -> int"""
        return _coin.SbHeap_size(self)


    def add(self, obj):
        """add(SbHeap self, void * obj) -> int"""
        return _coin.SbHeap_add(self, obj)


    def remove(self, *args):
        """
        remove(SbHeap self, int const pos)
        remove(SbHeap self, void * obj)
        """
        return _coin.SbHeap_remove(self, *args)


    def extractMin(self):
        """extractMin(SbHeap self) -> void *"""
        return _coin.SbHeap_extractMin(self)


    def getMin(self):
        """getMin(SbHeap self) -> void *"""
        return _coin.SbHeap_getMin(self)


    def newWeight(self, obj, hpos=-1):
        """
        newWeight(SbHeap self, void * obj, int hpos=-1)
        newWeight(SbHeap self, void * obj)
        """
        return _coin.SbHeap_newWeight(self, obj, hpos)


    def buildHeap(self, progresscb=None, data=None):
        """
        buildHeap(SbHeap self, SbBool (*)(float,void *) progresscb=None, void * data=None) -> SbBool
        buildHeap(SbHeap self, SbBool (*)(float,void *) progresscb=None) -> SbBool
        buildHeap(SbHeap self) -> SbBool
        """
        return _coin.SbHeap_buildHeap(self, progresscb, data)


    def traverseHeap(self, func, userdata):
        """traverseHeap(SbHeap self, SbBool (*)(void *,void *) func, void * userdata) -> SbBool"""
        return _coin.SbHeap_traverseHeap(self, func, userdata)

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__(SbImage self) -> SbImage
        __init__(SbImage self, unsigned char const * bytes) -> SbImage
        __init__(SbImage self, unsigned char const * 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(SbImage self, SbVec2s size)
        setValue(SbImage self, SbVec3s size)
        """
        return _coin.SbImage_setValue(self, *args)


    def setValuePtr(self, *args):
        """
        setValuePtr(SbImage self, SbVec2s size)
        setValuePtr(SbImage self, SbVec3s size)
        """
        return _coin.SbImage_setValuePtr(self, *args)


    def getSize(self):
        """getSize(SbImage self) -> SbVec3s"""
        return _coin.SbImage_getSize(self)


    def readFile(self, filename, searchdirectories=None, numdirectories=0):
        """
        readFile(SbImage self, SbString filename, SbString const *const * searchdirectories=None, int const numdirectories=0) -> SbBool
        readFile(SbImage self, SbString filename, SbString const *const * searchdirectories=None) -> SbBool
        readFile(SbImage self, SbString filename) -> SbBool
        """
        return _coin.SbImage_readFile(self, filename, searchdirectories, numdirectories)


    def __eq__(self, image):
        """__eq__(SbImage self, SbImage image) -> int"""
        return _coin.SbImage___eq__(self, image)


    def __ne__(self, image):
        """__ne__(SbImage self, SbImage image) -> int"""
        return _coin.SbImage___ne__(self, image)


    def addReadImageCB(cb, closure):
        """addReadImageCB(SbImageReadImageCB * cb, void * closure)"""
        return _coin.SbImage_addReadImageCB(cb, closure)

    addReadImageCB = staticmethod(addReadImageCB)

    def removeReadImageCB(cb, closure):
        """removeReadImageCB(SbImageReadImageCB * cb, void * closure)"""
        return _coin.SbImage_removeReadImageCB(cb, closure)

    removeReadImageCB = staticmethod(removeReadImageCB)

    def searchForFile(basename, dirlist, numdirs):
        """searchForFile(SbString basename, SbString const *const * dirlist, int const numdirs) -> SbString"""
        return _coin.SbImage_searchForFile(basename, dirlist, numdirs)

    searchForFile = staticmethod(searchForFile)

    def hasData(self):
        """hasData(SbImage self) -> SbBool"""
        return _coin.SbImage_hasData(self)


    def readLock(self):
        """readLock(SbImage self)"""
        return _coin.SbImage_readLock(self)


    def readUnlock(self):
        """readUnlock(SbImage self)"""
        return _coin.SbImage_readUnlock(self)


    def scheduleReadFile(self, cb, closure, filename, searchdirectories=None, numdirectories=0):
        """
        scheduleReadFile(SbImage self, SbImageScheduleReadCB * cb, void * closure, SbString filename, SbString const *const * searchdirectories=None, int const numdirectories=0) -> SbBool
        scheduleReadFile(SbImage self, SbImageScheduleReadCB * cb, void * closure, SbString filename, SbString const *const * searchdirectories=None) -> SbBool
        scheduleReadFile(SbImage self, SbImageScheduleReadCB * cb, void * closure, SbString filename) -> SbBool
        """
        return _coin.SbImage_scheduleReadFile(self, cb, closure, filename, searchdirectories, numdirectories)


    def getValue(self, *args):
        """
        getValue(SbImage self, SbVec2s size, int & bytesperpixel) -> unsigned char
        getValue(SbImage self, SbVec3s size, int & bytesperpixel) -> unsigned char
        getValue(SbImage self) -> PyObject *
        """
        return _coin.SbImage_getValue(self, *args)

SbImage_swigregister = _coin.SbImage_swigregister
SbImage_swigregister(SbImage)

def SbImage_addReadImageCB(cb, closure):
    """SbImage_addReadImageCB(SbImageReadImageCB * cb, void * closure)"""
    return _coin.SbImage_addReadImageCB(cb, closure)

def SbImage_removeReadImageCB(cb, closure):
    """SbImage_removeReadImageCB(SbImageReadImageCB * cb, void * closure)"""
    return _coin.SbImage_removeReadImageCB(cb, closure)

def SbImage_searchForFile(basename, dirlist, numdirs):
    """SbImage_searchForFile(SbString basename, SbString const *const * dirlist, int const numdirs) -> SbString"""
    return _coin.SbImage_searchForFile(basename, dirlist, numdirs)

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__(SbOctTreeFuncs 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, bbox, itemfuncs, maxitemspernode=64):
        """
        __init__(SbOctTree self, SbBox3f bbox, SbOctTreeFuncs itemfuncs, int const maxitemspernode=64) -> SbOctTree
        __init__(SbOctTree self, SbBox3f bbox, SbOctTreeFuncs itemfuncs) -> SbOctTree
        """
        this = _coin.new_SbOctTree(bbox, itemfuncs, maxitemspernode)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SbOctTree
    __del__ = lambda self: None

    def addItem(self, item):
        """addItem(SbOctTree self, void *const item)"""
        return _coin.SbOctTree_addItem(self, item)


    def removeItem(self, item):
        """removeItem(SbOctTree self, void *const item)"""
        return _coin.SbOctTree_removeItem(self, item)


    def findItems(self, *args):
        """
        findItems(SbOctTree self, SbVec3f pos, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbVec3f pos, SbList< void * > & destarray)
        findItems(SbOctTree self, SbBox3f box, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbBox3f box, SbList< void * > & destarray)
        findItems(SbOctTree self, SbSphere sphere, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbSphere sphere, SbList< void * > & destarray)
        findItems(SbOctTree self, SbPlane planes, int const numplanes, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbPlane planes, int const numplanes, SbList< void * > & destarray)
        """
        return _coin.SbOctTree_findItems(self, *args)


    def getBoundingBox(self):
        """getBoundingBox(SbOctTree self) -> SbBox3f"""
        return _coin.SbOctTree_getBoundingBox(self)


    def clear(self):
        """clear(SbOctTree self)"""
        return _coin.SbOctTree_clear(self)


    def debugTree(self, fp):
        """debugTree(SbOctTree self, FILE * fp)"""
        return _coin.SbOctTree_debugTree(self, fp)

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__(SbTesselator self, SbTesselatorCB * func=None, void * data=None) -> SbTesselator
        __init__(SbTesselator self, SbTesselatorCB * func=None) -> SbTesselator
        __init__(SbTesselator 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(SbTesselator self, SbBool keepVertices=0, SbVec3f normal)
        beginPolygon(SbTesselator self, SbBool keepVertices=0)
        beginPolygon(SbTesselator self)
        """
        return _coin.SbTesselator_beginPolygon(self, *args)


    def addVertex(self, v, data):
        """addVertex(SbTesselator self, SbVec3f v, void * data)"""
        return _coin.SbTesselator_addVertex(self, v, data)


    def endPolygon(self):
        """endPolygon(SbTesselator self)"""
        return _coin.SbTesselator_endPolygon(self)


    def setCallback(self, func, data):
        """setCallback(SbTesselator self, SbTesselatorCB * func, void * data)"""
        return _coin.SbTesselator_setCallback(self, func, data)

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(SoTimerQueueSensor self) -> SbTime"""
        return _coin.SoTimerQueueSensor_getTriggerTime(self)


    def schedule(self):
        """schedule(SoTimerQueueSensor self)"""
        return _coin.SoTimerQueueSensor_schedule(self)


    def unschedule(self):
        """unschedule(SoTimerQueueSensor self)"""
        return _coin.SoTimerQueueSensor_unschedule(self)


    def isScheduled(self):
        """isScheduled(SoTimerQueueSensor self) -> SbBool"""
        return _coin.SoTimerQueueSensor_isScheduled(self)


    def trigger(self):
        """trigger(SoTimerQueueSensor 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, abstime):
        """setTime(SoAlarmSensor self, SbTime abstime)"""
        return _coin.SoAlarmSensor_setTime(self, abstime)


    def setTimeFromNow(self, reltime):
        """setTimeFromNow(SoAlarmSensor self, SbTime reltime)"""
        return _coin.SoAlarmSensor_setTimeFromNow(self, reltime)


    def getTime(self):
        """getTime(SoAlarmSensor self) -> SbTime"""
        return _coin.SoAlarmSensor_getTime(self)


    def schedule(self):
        """schedule(SoAlarmSensor 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, node):
        """attach(SoNodeSensor self, SoNode node)"""
        return _coin.SoNodeSensor_attach(self, node)


    def detach(self):
        """detach(SoNodeSensor self)"""
        return _coin.SoNodeSensor_detach(self)


    def getAttachedNode(self):
        """getAttachedNode(SoNodeSensor 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, type):
        """setTriggerFilter(SoPathSensor self, SoPathSensor::TriggerFilter const type)"""
        return _coin.SoPathSensor_setTriggerFilter(self, type)


    def getTriggerFilter(self):
        """getTriggerFilter(SoPathSensor self) -> SoPathSensor::TriggerFilter"""
        return _coin.SoPathSensor_getTriggerFilter(self)


    def attach(self, path):
        """attach(SoPathSensor self, SoPath path)"""
        return _coin.SoPathSensor_attach(self, path)


    def detach(self):
        """detach(SoPathSensor self)"""
        return _coin.SoPathSensor_detach(self)


    def getAttachedPath(self):
        """getAttachedPath(SoPathSensor 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, base):
        """setBaseTime(SoTimerSensor self, SbTime base)"""
        return _coin.SoTimerSensor_setBaseTime(self, base)


    def getBaseTime(self):
        """getBaseTime(SoTimerSensor self) -> SbTime"""
        return _coin.SoTimerSensor_getBaseTime(self)


    def setInterval(self, interval):
        """setInterval(SoTimerSensor self, SbTime interval)"""
        return _coin.SoTimerSensor_setInterval(self, interval)


    def getInterval(self):
        """getInterval(SoTimerSensor self) -> SbTime"""
        return _coin.SoTimerSensor_getInterval(self)


    def schedule(self):
        """schedule(SoTimerSensor self)"""
        return _coin.SoTimerSensor_schedule(self)


    def unschedule(self):
        """unschedule(SoTimerSensor self)"""
        return _coin.SoTimerSensor_unschedule(self)


    def reschedule(self, schedtime):
        """reschedule(SoTimerSensor self, SbTime schedtime)"""
        return _coin.SoTimerSensor_reschedule(self, schedtime)

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__(SoInteraction 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__(SoOffscreenRenderer self, SbViewportRegion viewportregion) -> SoOffscreenRenderer
        __init__(SoOffscreenRenderer 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, components):
        """setComponents(SoOffscreenRenderer self, SoOffscreenRenderer::Components const components)"""
        return _coin.SoOffscreenRenderer_setComponents(self, components)


    def getComponents(self):
        """getComponents(SoOffscreenRenderer self) -> SoOffscreenRenderer::Components"""
        return _coin.SoOffscreenRenderer_getComponents(self)


    def setViewportRegion(self, region):
        """setViewportRegion(SoOffscreenRenderer self, SbViewportRegion region)"""
        return _coin.SoOffscreenRenderer_setViewportRegion(self, region)


    def getViewportRegion(self):
        """getViewportRegion(SoOffscreenRenderer self) -> SbViewportRegion"""
        return _coin.SoOffscreenRenderer_getViewportRegion(self)


    def setBackgroundColor(self, color):
        """setBackgroundColor(SoOffscreenRenderer self, SbColor color)"""
        return _coin.SoOffscreenRenderer_setBackgroundColor(self, color)


    def getBackgroundColor(self):
        """getBackgroundColor(SoOffscreenRenderer self) -> SbColor"""
        return _coin.SoOffscreenRenderer_getBackgroundColor(self)


    def setGLRenderAction(self, action):
        """setGLRenderAction(SoOffscreenRenderer self, SoGLRenderAction action)"""
        return _coin.SoOffscreenRenderer_setGLRenderAction(self, action)


    def getGLRenderAction(self):
        """getGLRenderAction(SoOffscreenRenderer self) -> SoGLRenderAction"""
        return _coin.SoOffscreenRenderer_getGLRenderAction(self)


    def render(self, *args):
        """
        render(SoOffscreenRenderer self, SoNode scene) -> SbBool
        render(SoOffscreenRenderer self, SoPath scene) -> SbBool
        """
        return _coin.SoOffscreenRenderer_render(self, *args)


    def getDC(self):
        """getDC(SoOffscreenRenderer self) -> void const *const &"""
        return _coin.SoOffscreenRenderer_getDC(self)


    def writeToRGB(self, *args):
        """
        writeToRGB(SoOffscreenRenderer self, FILE * fp) -> SbBool
        writeToRGB(SoOffscreenRenderer self, char const * filename) -> SbBool
        """
        return _coin.SoOffscreenRenderer_writeToRGB(self, *args)


    def writeToPostScript(self, *args):
        """
        writeToPostScript(SoOffscreenRenderer self, FILE * fp) -> SbBool
        writeToPostScript(SoOffscreenRenderer self, FILE * fp, SbVec2f printsize) -> SbBool
        writeToPostScript(SoOffscreenRenderer self, char const * filename) -> SbBool
        writeToPostScript(SoOffscreenRenderer self, char const * filename, SbVec2f printsize) -> SbBool
        """
        return _coin.SoOffscreenRenderer_writeToPostScript(self, *args)


    def isWriteSupported(self, filetypeextension):
        """isWriteSupported(SoOffscreenRenderer self, SbName filetypeextension) -> SbBool"""
        return _coin.SoOffscreenRenderer_isWriteSupported(self, filetypeextension)


    def getNumWriteFiletypes(self):
        """getNumWriteFiletypes(SoOffscreenRenderer self) -> int"""
        return _coin.SoOffscreenRenderer_getNumWriteFiletypes(self)


    def writeToFile(self, filename, filetypeextension):
        """writeToFile(SoOffscreenRenderer self, SbString filename, SbName filetypeextension) -> SbBool"""
        return _coin.SoOffscreenRenderer_writeToFile(self, filename, filetypeextension)


    def setPbufferEnable(self, enable):
        """setPbufferEnable(SoOffscreenRenderer self, SbBool enable)"""
        return _coin.SoOffscreenRenderer_setPbufferEnable(self, enable)


    def getPbufferEnable(self):
        """getPbufferEnable(SoOffscreenRenderer self) -> SbBool"""
        return _coin.SoOffscreenRenderer_getPbufferEnable(self)


    def getWriteFiletypeInfo(self, *args):
        """
        getWriteFiletypeInfo(SoOffscreenRenderer self, int const idx, SbPList extlist, SbString fullname, SbString description)
        getWriteFiletypeInfo(SoOffscreenRenderer self, int const idx, SbList< SbName > & extlist, SbString fullname, SbString description)
        """
        return _coin.SoOffscreenRenderer_getWriteFiletypeInfo(self, *args)


    def getBuffer(self, *args):
        """
        getBuffer(SoOffscreenRenderer self) -> unsigned char
        getBuffer(SoOffscreenRenderer 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__(SoPickedPoint self, SoPickedPoint pp) -> SoPickedPoint
        __init__(SoPickedPoint 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(SoPickedPoint self) -> SoPickedPoint"""
        return _coin.SoPickedPoint_copy(self)


    def getPoint(self):
        """getPoint(SoPickedPoint self) -> SbVec3f"""
        return _coin.SoPickedPoint_getPoint(self)


    def getNormal(self):
        """getNormal(SoPickedPoint self) -> SbVec3f"""
        return _coin.SoPickedPoint_getNormal(self)


    def getTextureCoords(self):
        """getTextureCoords(SoPickedPoint self) -> SbVec4f"""
        return _coin.SoPickedPoint_getTextureCoords(self)


    def getMaterialIndex(self):
        """getMaterialIndex(SoPickedPoint self) -> int"""
        return _coin.SoPickedPoint_getMaterialIndex(self)


    def getPath(self):
        """getPath(SoPickedPoint self) -> SoPath"""
        return _coin.SoPickedPoint_getPath(self)


    def isOnGeometry(self):
        """isOnGeometry(SoPickedPoint self) -> SbBool"""
        return _coin.SoPickedPoint_isOnGeometry(self)


    def getDetail(self, node=None):
        """
        getDetail(SoPickedPoint self, SoNode node=None) -> SoDetail
        getDetail(SoPickedPoint self) -> SoDetail
        """
        return _coin.SoPickedPoint_getDetail(self, node)


    def getObjectToWorld(self, node=None):
        """
        getObjectToWorld(SoPickedPoint self, SoNode node=None) -> SbMatrix
        getObjectToWorld(SoPickedPoint self) -> SbMatrix
        """
        return _coin.SoPickedPoint_getObjectToWorld(self, node)


    def getWorldToObject(self, node=None):
        """
        getWorldToObject(SoPickedPoint self, SoNode node=None) -> SbMatrix
        getWorldToObject(SoPickedPoint self) -> SbMatrix
        """
        return _coin.SoPickedPoint_getWorldToObject(self, node)


    def getObjectToImage(self, node=None):
        """
        getObjectToImage(SoPickedPoint self, SoNode node=None) -> SbMatrix
        getObjectToImage(SoPickedPoint self) -> SbMatrix
        """
        return _coin.SoPickedPoint_getObjectToImage(self, node)


    def getImageToObject(self, node=None):
        """
        getImageToObject(SoPickedPoint self, SoNode node=None) -> SbMatrix
        getImageToObject(SoPickedPoint self) -> SbMatrix
        """
        return _coin.SoPickedPoint_getImageToObject(self, node)


    def getObjectPoint(self, node=None):
        """
        getObjectPoint(SoPickedPoint self, SoNode node=None) -> SbVec3f
        getObjectPoint(SoPickedPoint self) -> SbVec3f
        """
        return _coin.SoPickedPoint_getObjectPoint(self, node)


    def getObjectNormal(self, node=None):
        """
        getObjectNormal(SoPickedPoint self, SoNode node=None) -> SbVec3f
        getObjectNormal(SoPickedPoint self) -> SbVec3f
        """
        return _coin.SoPickedPoint_getObjectNormal(self, node)


    def getObjectTextureCoords(self, node=None):
        """
        getObjectTextureCoords(SoPickedPoint self, SoNode node=None) -> SbVec4f
        getObjectTextureCoords(SoPickedPoint self) -> SbVec4f
        """
        return _coin.SoPickedPoint_getObjectTextureCoords(self, node)


    def setObjectNormal(self, normal):
        """setObjectNormal(SoPickedPoint self, SbVec3f normal)"""
        return _coin.SoPickedPoint_setObjectNormal(self, normal)


    def setObjectTextureCoords(self, texCoords):
        """setObjectTextureCoords(SoPickedPoint self, SbVec4f texCoords)"""
        return _coin.SoPickedPoint_setObjectTextureCoords(self, texCoords)


    def setMaterialIndex(self, index):
        """setMaterialIndex(SoPickedPoint self, int const index)"""
        return _coin.SoPickedPoint_setMaterialIndex(self, index)


    def setDetail(self, detail, node):
        """setDetail(SoPickedPoint self, SoDetail detail, SoNode node)"""
        return _coin.SoPickedPoint_setDetail(self, detail, node)

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__(SoPrimitiveVertex self) -> SoPrimitiveVertex
        __init__(SoPrimitiveVertex 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(SoPrimitiveVertex self) -> SbVec3f"""
        return _coin.SoPrimitiveVertex_getPoint(self)


    def getNormal(self):
        """getNormal(SoPrimitiveVertex self) -> SbVec3f"""
        return _coin.SoPrimitiveVertex_getNormal(self)


    def getTextureCoords(self):
        """getTextureCoords(SoPrimitiveVertex self) -> SbVec4f"""
        return _coin.SoPrimitiveVertex_getTextureCoords(self)


    def getMaterialIndex(self):
        """getMaterialIndex(SoPrimitiveVertex self) -> int"""
        return _coin.SoPrimitiveVertex_getMaterialIndex(self)


    def getPackedColor(self):
        """getPackedColor(SoPrimitiveVertex self) -> uint32_t"""
        return _coin.SoPrimitiveVertex_getPackedColor(self)


    def getDetail(self):
        """getDetail(SoPrimitiveVertex self) -> SoDetail"""
        return _coin.SoPrimitiveVertex_getDetail(self)


    def setPoint(self, *args):
        """
        setPoint(SoPrimitiveVertex self, SbVec3f pt)
        setPoint(SoPrimitiveVertex self, float x, float y, float z)
        """
        return _coin.SoPrimitiveVertex_setPoint(self, *args)


    def setNormal(self, *args):
        """
        setNormal(SoPrimitiveVertex self, SbVec3f n)
        setNormal(SoPrimitiveVertex self, float nx, float ny, float nz)
        """
        return _coin.SoPrimitiveVertex_setNormal(self, *args)


    def setTextureCoords(self, *args):
        """
        setTextureCoords(SoPrimitiveVertex self, SbVec2f tex)
        setTextureCoords(SoPrimitiveVertex self, float tx, float ty)
        setTextureCoords(SoPrimitiveVertex self, SbVec3f tex)
        setTextureCoords(SoPrimitiveVertex self, float tx, float ty, float tz)
        setTextureCoords(SoPrimitiveVertex self, SbVec4f tex)
        setTextureCoords(SoPrimitiveVertex self, float tx, float ty, float tz, float tw)
        """
        return _coin.SoPrimitiveVertex_setTextureCoords(self, *args)


    def setMaterialIndex(self, index):
        """setMaterialIndex(SoPrimitiveVertex self, int index)"""
        return _coin.SoPrimitiveVertex_setMaterialIndex(self, index)


    def setPackedColor(self, rgba):
        """setPackedColor(SoPrimitiveVertex self, uint32_t rgba)"""
        return _coin.SoPrimitiveVertex_setPackedColor(self, rgba)


    def setDetail(self, d):
        """setDetail(SoPrimitiveVertex self, SoDetail d)"""
        return _coin.SoPrimitiveVertex_setDetail(self, d)

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__(SoSceneManager 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(SoSceneManager self, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        render(SoSceneManager self, SbBool const clearwindow=1)
        render(SoSceneManager self)
        render(SoSceneManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        render(SoSceneManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1)
        render(SoSceneManager self, SoGLRenderAction action, SbBool const initmatrices=1)
        render(SoSceneManager self, SoGLRenderAction action)
        """
        return _coin.SoSceneManager_render(self, *args)


    def setCamera(self, camera):
        """setCamera(SoSceneManager self, SoCamera camera)"""
        return _coin.SoSceneManager_setCamera(self, camera)


    def getCamera(self):
        """getCamera(SoSceneManager self) -> SoCamera"""
        return _coin.SoSceneManager_getCamera(self)


    def processEvent(self, event):
        """processEvent(SoSceneManager self, SoEvent event) -> SbBool"""
        return _coin.SoSceneManager_processEvent(self, event)


    def reinitialize(self):
        """reinitialize(SoSceneManager self)"""
        return _coin.SoSceneManager_reinitialize(self)


    def scheduleRedraw(self):
        """scheduleRedraw(SoSceneManager self)"""
        return _coin.SoSceneManager_scheduleRedraw(self)


    def setSceneGraph(self, sceneroot):
        """setSceneGraph(SoSceneManager self, SoNode sceneroot)"""
        return _coin.SoSceneManager_setSceneGraph(self, sceneroot)


    def getSceneGraph(self):
        """getSceneGraph(SoSceneManager self) -> SoNode"""
        return _coin.SoSceneManager_getSceneGraph(self)


    def setWindowSize(self, newsize):
        """setWindowSize(SoSceneManager self, SbVec2s newsize)"""
        return _coin.SoSceneManager_setWindowSize(self, newsize)


    def getWindowSize(self):
        """getWindowSize(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getWindowSize(self)


    def setSize(self, newsize):
        """setSize(SoSceneManager self, SbVec2s newsize)"""
        return _coin.SoSceneManager_setSize(self, newsize)


    def getSize(self):
        """getSize(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getSize(self)


    def setOrigin(self, newOrigin):
        """setOrigin(SoSceneManager self, SbVec2s newOrigin)"""
        return _coin.SoSceneManager_setOrigin(self, newOrigin)


    def getOrigin(self):
        """getOrigin(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getOrigin(self)


    def setViewportRegion(self, newRegion):
        """setViewportRegion(SoSceneManager self, SbViewportRegion newRegion)"""
        return _coin.SoSceneManager_setViewportRegion(self, newRegion)


    def getViewportRegion(self):
        """getViewportRegion(SoSceneManager self) -> SbViewportRegion"""
        return _coin.SoSceneManager_getViewportRegion(self)


    def setBackgroundColor(self, color):
        """setBackgroundColor(SoSceneManager self, SbColor color)"""
        return _coin.SoSceneManager_setBackgroundColor(self, color)


    def getBackgroundColor(self):
        """getBackgroundColor(SoSceneManager self) -> SbColor"""
        return _coin.SoSceneManager_getBackgroundColor(self)


    def setBackgroundIndex(self, index):
        """setBackgroundIndex(SoSceneManager self, int const index)"""
        return _coin.SoSceneManager_setBackgroundIndex(self, index)


    def getBackgroundIndex(self):
        """getBackgroundIndex(SoSceneManager self) -> int"""
        return _coin.SoSceneManager_getBackgroundIndex(self)


    def setRGBMode(self, onOrOff):
        """setRGBMode(SoSceneManager self, SbBool const onOrOff)"""
        return _coin.SoSceneManager_setRGBMode(self, onOrOff)


    def isRGBMode(self):
        """isRGBMode(SoSceneManager self) -> SbBool"""
        return _coin.SoSceneManager_isRGBMode(self)


    def activate(self):
        """activate(SoSceneManager self)"""
        return _coin.SoSceneManager_activate(self)


    def deactivate(self):
        """deactivate(SoSceneManager self)"""
        return _coin.SoSceneManager_deactivate(self)


    def isAutoRedraw(self):
        """isAutoRedraw(SoSceneManager self) -> SbBool"""
        return _coin.SoSceneManager_isAutoRedraw(self)


    def setRedrawPriority(self, priority):
        """setRedrawPriority(SoSceneManager self, uint32_t const priority)"""
        return _coin.SoSceneManager_setRedrawPriority(self, priority)


    def getRedrawPriority(self):
        """getRedrawPriority(SoSceneManager self) -> uint32_t"""
        return _coin.SoSceneManager_getRedrawPriority(self)


    def setAntialiasing(self, smoothing, numPasses):
        """setAntialiasing(SoSceneManager self, SbBool const smoothing, int const numPasses)"""
        return _coin.SoSceneManager_setAntialiasing(self, smoothing, numPasses)


    def getAntialiasing(self, smoothing, numPasses):
        """getAntialiasing(SoSceneManager self, SbBool & smoothing, int & numPasses)"""
        return _coin.SoSceneManager_getAntialiasing(self, smoothing, numPasses)


    def setGLRenderAction(self, action):
        """setGLRenderAction(SoSceneManager self, SoGLRenderAction action)"""
        return _coin.SoSceneManager_setGLRenderAction(self, action)


    def getGLRenderAction(self):
        """getGLRenderAction(SoSceneManager self) -> SoGLRenderAction"""
        return _coin.SoSceneManager_getGLRenderAction(self)


    def setAudioRenderAction(self, action):
        """setAudioRenderAction(SoSceneManager self, SoAudioRenderAction action)"""
        return _coin.SoSceneManager_setAudioRenderAction(self, action)


    def getAudioRenderAction(self):
        """getAudioRenderAction(SoSceneManager self) -> SoAudioRenderAction"""
        return _coin.SoSceneManager_getAudioRenderAction(self)


    def setHandleEventAction(self, hea):
        """setHandleEventAction(SoSceneManager self, SoHandleEventAction hea)"""
        return _coin.SoSceneManager_setHandleEventAction(self, hea)


    def getHandleEventAction(self):
        """getHandleEventAction(SoSceneManager self) -> SoHandleEventAction"""
        return _coin.SoSceneManager_getHandleEventAction(self)


    def getDefaultRedrawPriority():
        """getDefaultRedrawPriority() -> uint32_t"""
        return _coin.SoSceneManager_getDefaultRedrawPriority()

    getDefaultRedrawPriority = staticmethod(getDefaultRedrawPriority)

    def enableRealTimeUpdate(flag):
        """enableRealTimeUpdate(SbBool const flag)"""
        return _coin.SoSceneManager_enableRealTimeUpdate(flag)

    enableRealTimeUpdate = staticmethod(enableRealTimeUpdate)

    def isRealTimeUpdateEnabled():
        """isRealTimeUpdateEnabled() -> SbBool"""
        return _coin.SoSceneManager_isRealTimeUpdateEnabled()

    isRealTimeUpdateEnabled = staticmethod(isRealTimeUpdateEnabled)

    def setRenderCallback(self, *args):
        """
        setRenderCallback(SoSceneManager self, SoSceneManagerRenderCB * f, void *const userData=None)
        setRenderCallback(SoSceneManager self, SoSceneManagerRenderCB * f)
        setRenderCallback(SoSceneManager self, PyObject * pyfunc, PyObject * userData=None)
        setRenderCallback(SoSceneManager 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(flag):
    """SoSceneManager_enableRealTimeUpdate(SbBool const flag)"""
    return _coin.SoSceneManager_enableRealTimeUpdate(flag)

def SoSceneManager_isRealTimeUpdateEnabled():
    """SoSceneManager_isRealTimeUpdateEnabled() -> SbBool"""
    return _coin.SoSceneManager_isRealTimeUpdateEnabled()


_coin.GL_GLEXT_PROTOTYPES_swigconstant(_coin)
GL_GLEXT_PROTOTYPES = _coin.GL_GLEXT_PROTOTYPES

_coin.GL_CLAMP_TO_EDGE_swigconstant(_coin)
GL_CLAMP_TO_EDGE = _coin.GL_CLAMP_TO_EDGE

_coin.GL_CLAMP_TO_BORDER_swigconstant(_coin)
GL_CLAMP_TO_BORDER = _coin.GL_CLAMP_TO_BORDER

_coin.GL_REPLACE_swigconstant(_coin)
GL_REPLACE = _coin.GL_REPLACE

_coin.GL_MAX_3D_TEXTURE_SIZE_swigconstant(_coin)
GL_MAX_3D_TEXTURE_SIZE = _coin.GL_MAX_3D_TEXTURE_SIZE

_coin.GL_PACK_IMAGE_HEIGHT_swigconstant(_coin)
GL_PACK_IMAGE_HEIGHT = _coin.GL_PACK_IMAGE_HEIGHT

_coin.GL_PACK_SKIP_IMAGES_swigconstant(_coin)
GL_PACK_SKIP_IMAGES = _coin.GL_PACK_SKIP_IMAGES

_coin.GL_PROXY_TEXTURE_2D_swigconstant(_coin)
GL_PROXY_TEXTURE_2D = _coin.GL_PROXY_TEXTURE_2D

_coin.GL_PROXY_TEXTURE_3D_swigconstant(_coin)
GL_PROXY_TEXTURE_3D = _coin.GL_PROXY_TEXTURE_3D

_coin.GL_TEXTURE_3D_swigconstant(_coin)
GL_TEXTURE_3D = _coin.GL_TEXTURE_3D

_coin.GL_TEXTURE_DEPTH_swigconstant(_coin)
GL_TEXTURE_DEPTH = _coin.GL_TEXTURE_DEPTH

_coin.GL_TEXTURE_WRAP_R_swigconstant(_coin)
GL_TEXTURE_WRAP_R = _coin.GL_TEXTURE_WRAP_R

_coin.GL_UNPACK_IMAGE_HEIGHT_swigconstant(_coin)
GL_UNPACK_IMAGE_HEIGHT = _coin.GL_UNPACK_IMAGE_HEIGHT

_coin.GL_UNPACK_SKIP_IMAGES_swigconstant(_coin)
GL_UNPACK_SKIP_IMAGES = _coin.GL_UNPACK_SKIP_IMAGES

_coin.GL_COLOR_TABLE_WIDTH_swigconstant(_coin)
GL_COLOR_TABLE_WIDTH = _coin.GL_COLOR_TABLE_WIDTH

_coin.GL_TEXTURE0_swigconstant(_coin)
GL_TEXTURE0 = _coin.GL_TEXTURE0

_coin.GL_TEXTURE1_swigconstant(_coin)
GL_TEXTURE1 = _coin.GL_TEXTURE1

_coin.GL_TEXTURE2_swigconstant(_coin)
GL_TEXTURE2 = _coin.GL_TEXTURE2

_coin.GL_TEXTURE3_swigconstant(_coin)
GL_TEXTURE3 = _coin.GL_TEXTURE3

_coin.GL_TEXTURE4_swigconstant(_coin)
GL_TEXTURE4 = _coin.GL_TEXTURE4

_coin.GL_TEXTURE5_swigconstant(_coin)
GL_TEXTURE5 = _coin.GL_TEXTURE5

_coin.GL_TEXTURE6_swigconstant(_coin)
GL_TEXTURE6 = _coin.GL_TEXTURE6

_coin.GL_TEXTURE7_swigconstant(_coin)
GL_TEXTURE7 = _coin.GL_TEXTURE7

_coin.GL_TEXTURE8_swigconstant(_coin)
GL_TEXTURE8 = _coin.GL_TEXTURE8

_coin.GL_TEXTURE9_swigconstant(_coin)
GL_TEXTURE9 = _coin.GL_TEXTURE9

_coin.GL_TEXTURE10_swigconstant(_coin)
GL_TEXTURE10 = _coin.GL_TEXTURE10

_coin.GL_TEXTURE11_swigconstant(_coin)
GL_TEXTURE11 = _coin.GL_TEXTURE11

_coin.GL_TEXTURE12_swigconstant(_coin)
GL_TEXTURE12 = _coin.GL_TEXTURE12

_coin.GL_TEXTURE13_swigconstant(_coin)
GL_TEXTURE13 = _coin.GL_TEXTURE13

_coin.GL_TEXTURE14_swigconstant(_coin)
GL_TEXTURE14 = _coin.GL_TEXTURE14

_coin.GL_TEXTURE15_swigconstant(_coin)
GL_TEXTURE15 = _coin.GL_TEXTURE15

_coin.GL_MAX_TEXTURE_UNITS_swigconstant(_coin)
GL_MAX_TEXTURE_UNITS = _coin.GL_MAX_TEXTURE_UNITS

_coin.GL_ACTIVE_TEXTURE_swigconstant(_coin)
GL_ACTIVE_TEXTURE = _coin.GL_ACTIVE_TEXTURE

_coin.GL_CLIENT_ACTIVE_TEXTURE_swigconstant(_coin)
GL_CLIENT_ACTIVE_TEXTURE = _coin.GL_CLIENT_ACTIVE_TEXTURE

_coin.GL_POLYGON_OFFSET_EXT_swigconstant(_coin)
GL_POLYGON_OFFSET_EXT = _coin.GL_POLYGON_OFFSET_EXT

_coin.GL_COLOR_TABLE_swigconstant(_coin)
GL_COLOR_TABLE = _coin.GL_COLOR_TABLE

_coin.GL_COLOR_INDEX1_EXT_swigconstant(_coin)
GL_COLOR_INDEX1_EXT = _coin.GL_COLOR_INDEX1_EXT

_coin.GL_COLOR_INDEX2_EXT_swigconstant(_coin)
GL_COLOR_INDEX2_EXT = _coin.GL_COLOR_INDEX2_EXT

_coin.GL_COLOR_INDEX4_EXT_swigconstant(_coin)
GL_COLOR_INDEX4_EXT = _coin.GL_COLOR_INDEX4_EXT

_coin.GL_COLOR_INDEX8_EXT_swigconstant(_coin)
GL_COLOR_INDEX8_EXT = _coin.GL_COLOR_INDEX8_EXT

_coin.GL_COLOR_INDEX12_EXT_swigconstant(_coin)
GL_COLOR_INDEX12_EXT = _coin.GL_COLOR_INDEX12_EXT

_coin.GL_COLOR_INDEX16_EXT_swigconstant(_coin)
GL_COLOR_INDEX16_EXT = _coin.GL_COLOR_INDEX16_EXT

_coin.GL_COLOR_TABLE_FORMAT_EXT_swigconstant(_coin)
GL_COLOR_TABLE_FORMAT_EXT = _coin.GL_COLOR_TABLE_FORMAT_EXT

_coin.GL_COLOR_TABLE_RED_SIZE_EXT_swigconstant(_coin)
GL_COLOR_TABLE_RED_SIZE_EXT = _coin.GL_COLOR_TABLE_RED_SIZE_EXT

_coin.GL_COLOR_TABLE_GREEN_SIZE_EXT_swigconstant(_coin)
GL_COLOR_TABLE_GREEN_SIZE_EXT = _coin.GL_COLOR_TABLE_GREEN_SIZE_EXT

_coin.GL_COLOR_TABLE_BLUE_SIZE_EXT_swigconstant(_coin)
GL_COLOR_TABLE_BLUE_SIZE_EXT = _coin.GL_COLOR_TABLE_BLUE_SIZE_EXT

_coin.GL_COLOR_TABLE_ALPHA_SIZE_EXT_swigconstant(_coin)
GL_COLOR_TABLE_ALPHA_SIZE_EXT = _coin.GL_COLOR_TABLE_ALPHA_SIZE_EXT

_coin.GL_COLOR_TABLE_LUMINANCE_SIZE_EXT_swigconstant(_coin)
GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = _coin.GL_COLOR_TABLE_LUMINANCE_SIZE_EXT

_coin.GL_COLOR_TABLE_INTENSITY_SIZE_EXT_swigconstant(_coin)
GL_COLOR_TABLE_INTENSITY_SIZE_EXT = _coin.GL_COLOR_TABLE_INTENSITY_SIZE_EXT

_coin.GL_TEXTURE_INDEX_SIZE_EXT_swigconstant(_coin)
GL_TEXTURE_INDEX_SIZE_EXT = _coin.GL_TEXTURE_INDEX_SIZE_EXT

_coin.GL_COMPRESSED_ALPHA_ARB_swigconstant(_coin)
GL_COMPRESSED_ALPHA_ARB = _coin.GL_COMPRESSED_ALPHA_ARB

_coin.GL_COMPRESSED_LUMINANCE_ARB_swigconstant(_coin)
GL_COMPRESSED_LUMINANCE_ARB = _coin.GL_COMPRESSED_LUMINANCE_ARB

_coin.GL_COMPRESSED_LUMINANCE_ALPHA_ARB_swigconstant(_coin)
GL_COMPRESSED_LUMINANCE_ALPHA_ARB = _coin.GL_COMPRESSED_LUMINANCE_ALPHA_ARB

_coin.GL_COMPRESSED_INTENSITY_ARB_swigconstant(_coin)
GL_COMPRESSED_INTENSITY_ARB = _coin.GL_COMPRESSED_INTENSITY_ARB

_coin.GL_COMPRESSED_RGB_ARB_swigconstant(_coin)
GL_COMPRESSED_RGB_ARB = _coin.GL_COMPRESSED_RGB_ARB

_coin.GL_COMPRESSED_RGBA_ARB_swigconstant(_coin)
GL_COMPRESSED_RGBA_ARB = _coin.GL_COMPRESSED_RGBA_ARB

_coin.GL_TEXTURE_COMPRESSION_HINT_ARB_swigconstant(_coin)
GL_TEXTURE_COMPRESSION_HINT_ARB = _coin.GL_TEXTURE_COMPRESSION_HINT_ARB

_coin.GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB_swigconstant(_coin)
GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = _coin.GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB

_coin.GL_TEXTURE_COMPRESSED_ARB_swigconstant(_coin)
GL_TEXTURE_COMPRESSED_ARB = _coin.GL_TEXTURE_COMPRESSED_ARB

_coin.GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB_swigconstant(_coin)
GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = _coin.GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB

_coin.GL_COMPRESSED_TEXTURE_FORMATS_ARB_swigconstant(_coin)
GL_COMPRESSED_TEXTURE_FORMATS_ARB = _coin.GL_COMPRESSED_TEXTURE_FORMATS_ARB

_coin.GL_DEPTH_COMPONENT16_swigconstant(_coin)
GL_DEPTH_COMPONENT16 = _coin.GL_DEPTH_COMPONENT16

_coin.GL_DEPTH_COMPONENT24_swigconstant(_coin)
GL_DEPTH_COMPONENT24 = _coin.GL_DEPTH_COMPONENT24

_coin.GL_DEPTH_COMPONENT32_swigconstant(_coin)
GL_DEPTH_COMPONENT32 = _coin.GL_DEPTH_COMPONENT32

_coin.GL_TEXTURE_DEPTH_SIZE_swigconstant(_coin)
GL_TEXTURE_DEPTH_SIZE = _coin.GL_TEXTURE_DEPTH_SIZE

_coin.GL_DEPTH_TEXTURE_MODE_swigconstant(_coin)
GL_DEPTH_TEXTURE_MODE = _coin.GL_DEPTH_TEXTURE_MODE

_coin.GL_R3_G3_B2_swigconstant(_coin)
GL_R3_G3_B2 = _coin.GL_R3_G3_B2

_coin.GL_RGB4_swigconstant(_coin)
GL_RGB4 = _coin.GL_RGB4

_coin.GL_RGB5_swigconstant(_coin)
GL_RGB5 = _coin.GL_RGB5

_coin.GL_RGB8_swigconstant(_coin)
GL_RGB8 = _coin.GL_RGB8

_coin.GL_RGB10_swigconstant(_coin)
GL_RGB10 = _coin.GL_RGB10

_coin.GL_RGB12_swigconstant(_coin)
GL_RGB12 = _coin.GL_RGB12

_coin.GL_RGB16_swigconstant(_coin)
GL_RGB16 = _coin.GL_RGB16

_coin.GL_RGBA2_swigconstant(_coin)
GL_RGBA2 = _coin.GL_RGBA2

_coin.GL_RGBA4_swigconstant(_coin)
GL_RGBA4 = _coin.GL_RGBA4

_coin.GL_RGB5_A1_swigconstant(_coin)
GL_RGB5_A1 = _coin.GL_RGB5_A1

_coin.GL_RGBA8_swigconstant(_coin)
GL_RGBA8 = _coin.GL_RGBA8

_coin.GL_RGB10_A2_swigconstant(_coin)
GL_RGB10_A2 = _coin.GL_RGB10_A2

_coin.GL_RGBA12_swigconstant(_coin)
GL_RGBA12 = _coin.GL_RGBA12

_coin.GL_RGBA16_swigconstant(_coin)
GL_RGBA16 = _coin.GL_RGBA16

_coin.GL_RGBA32F_ARB_swigconstant(_coin)
GL_RGBA32F_ARB = _coin.GL_RGBA32F_ARB

_coin.GL_RGB32F_ARB_swigconstant(_coin)
GL_RGB32F_ARB = _coin.GL_RGB32F_ARB

_coin.GL_ALPHA32F_ARB_swigconstant(_coin)
GL_ALPHA32F_ARB = _coin.GL_ALPHA32F_ARB

_coin.GL_INTENSITY32F_ARB_swigconstant(_coin)
GL_INTENSITY32F_ARB = _coin.GL_INTENSITY32F_ARB

_coin.GL_LUMINANCE32F_ARB_swigconstant(_coin)
GL_LUMINANCE32F_ARB = _coin.GL_LUMINANCE32F_ARB

_coin.GL_LUMINANCE_ALPHA32F_ARB_swigconstant(_coin)
GL_LUMINANCE_ALPHA32F_ARB = _coin.GL_LUMINANCE_ALPHA32F_ARB

_coin.GL_RGBA16F_ARB_swigconstant(_coin)
GL_RGBA16F_ARB = _coin.GL_RGBA16F_ARB

_coin.GL_RGB16F_ARB_swigconstant(_coin)
GL_RGB16F_ARB = _coin.GL_RGB16F_ARB

_coin.GL_ALPHA16F_ARB_swigconstant(_coin)
GL_ALPHA16F_ARB = _coin.GL_ALPHA16F_ARB

_coin.GL_INTENSITY16F_ARB_swigconstant(_coin)
GL_INTENSITY16F_ARB = _coin.GL_INTENSITY16F_ARB

_coin.GL_LUMINANCE16F_ARB_swigconstant(_coin)
GL_LUMINANCE16F_ARB = _coin.GL_LUMINANCE16F_ARB

_coin.GL_LUMINANCE_ALPHA16F_ARB_swigconstant(_coin)
GL_LUMINANCE_ALPHA16F_ARB = _coin.GL_LUMINANCE_ALPHA16F_ARB

_coin.GL_RGBA16_EXT_swigconstant(_coin)
GL_RGBA16_EXT = _coin.GL_RGBA16_EXT

_coin.GL_TEXTURE_COMPARE_MODE_swigconstant(_coin)
GL_TEXTURE_COMPARE_MODE = _coin.GL_TEXTURE_COMPARE_MODE

_coin.GL_TEXTURE_COMPARE_FUNC_swigconstant(_coin)
GL_TEXTURE_COMPARE_FUNC = _coin.GL_TEXTURE_COMPARE_FUNC

_coin.GL_COMPARE_R_TO_TEXTURE_swigconstant(_coin)
GL_COMPARE_R_TO_TEXTURE = _coin.GL_COMPARE_R_TO_TEXTURE

_coin.GL_MIN_swigconstant(_coin)
GL_MIN = _coin.GL_MIN

_coin.GL_MAX_swigconstant(_coin)
GL_MAX = _coin.GL_MAX

_coin.GL_FUNC_ADD_swigconstant(_coin)
GL_FUNC_ADD = _coin.GL_FUNC_ADD

_coin.GL_FUNC_SUBTRACT_swigconstant(_coin)
GL_FUNC_SUBTRACT = _coin.GL_FUNC_SUBTRACT

_coin.GL_FUNC_REVERSE_SUBTRACT_swigconstant(_coin)
GL_FUNC_REVERSE_SUBTRACT = _coin.GL_FUNC_REVERSE_SUBTRACT

_coin.GL_VERTEX_ARRAY_swigconstant(_coin)
GL_VERTEX_ARRAY = _coin.GL_VERTEX_ARRAY

_coin.GL_NORMAL_ARRAY_swigconstant(_coin)
GL_NORMAL_ARRAY = _coin.GL_NORMAL_ARRAY

_coin.GL_COLOR_ARRAY_swigconstant(_coin)
GL_COLOR_ARRAY = _coin.GL_COLOR_ARRAY

_coin.GL_INDEX_ARRAY_swigconstant(_coin)
GL_INDEX_ARRAY = _coin.GL_INDEX_ARRAY

_coin.GL_TEXTURE_COORD_ARRAY_swigconstant(_coin)
GL_TEXTURE_COORD_ARRAY = _coin.GL_TEXTURE_COORD_ARRAY

_coin.GL_V3F_swigconstant(_coin)
GL_V3F = _coin.GL_V3F

_coin.GL_C4UB_V3F_swigconstant(_coin)
GL_C4UB_V3F = _coin.GL_C4UB_V3F

_coin.GL_C3F_V3F_swigconstant(_coin)
GL_C3F_V3F = _coin.GL_C3F_V3F

_coin.GL_N3F_V3F_swigconstant(_coin)
GL_N3F_V3F = _coin.GL_N3F_V3F

_coin.GL_C4F_N3F_V3F_swigconstant(_coin)
GL_C4F_N3F_V3F = _coin.GL_C4F_N3F_V3F

_coin.GL_T2F_V3F_swigconstant(_coin)
GL_T2F_V3F = _coin.GL_T2F_V3F

_coin.GL_T2F_C4UB_V3F_swigconstant(_coin)
GL_T2F_C4UB_V3F = _coin.GL_T2F_C4UB_V3F

_coin.GL_T2F_C3F_V3F_swigconstant(_coin)
GL_T2F_C3F_V3F = _coin.GL_T2F_C3F_V3F

_coin.GL_T2F_N3F_V3F_swigconstant(_coin)
GL_T2F_N3F_V3F = _coin.GL_T2F_N3F_V3F

_coin.GL_T2F_C4F_N3F_V3F_swigconstant(_coin)
GL_T2F_C4F_N3F_V3F = _coin.GL_T2F_C4F_N3F_V3F

_coin.GL_VERTEX_ARRAY_RANGE_NV_swigconstant(_coin)
GL_VERTEX_ARRAY_RANGE_NV = _coin.GL_VERTEX_ARRAY_RANGE_NV

_coin.GL_VERTEX_ARRAY_RANGE_LENGTH_NV_swigconstant(_coin)
GL_VERTEX_ARRAY_RANGE_LENGTH_NV = _coin.GL_VERTEX_ARRAY_RANGE_LENGTH_NV

_coin.GL_VERTEX_ARRAY_RANGE_VALID_NV_swigconstant(_coin)
GL_VERTEX_ARRAY_RANGE_VALID_NV = _coin.GL_VERTEX_ARRAY_RANGE_VALID_NV

_coin.GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV_swigconstant(_coin)
GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = _coin.GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV

_coin.GL_VERTEX_ARRAY_RANGE_POINTER_NV_swigconstant(_coin)
GL_VERTEX_ARRAY_RANGE_POINTER_NV = _coin.GL_VERTEX_ARRAY_RANGE_POINTER_NV

_coin.GL_ARRAY_BUFFER_swigconstant(_coin)
GL_ARRAY_BUFFER = _coin.GL_ARRAY_BUFFER

_coin.GL_ELEMENT_ARRAY_BUFFER_swigconstant(_coin)
GL_ELEMENT_ARRAY_BUFFER = _coin.GL_ELEMENT_ARRAY_BUFFER

_coin.GL_READ_ONLY_swigconstant(_coin)
GL_READ_ONLY = _coin.GL_READ_ONLY

_coin.GL_WRITE_ONLY_swigconstant(_coin)
GL_WRITE_ONLY = _coin.GL_WRITE_ONLY

_coin.GL_READ_WRITE_swigconstant(_coin)
GL_READ_WRITE = _coin.GL_READ_WRITE

_coin.GL_BUFFER_ACCESS_swigconstant(_coin)
GL_BUFFER_ACCESS = _coin.GL_BUFFER_ACCESS

_coin.GL_BUFFER_MAPPED_swigconstant(_coin)
GL_BUFFER_MAPPED = _coin.GL_BUFFER_MAPPED

_coin.GL_BUFFER_MAP_POINTER_swigconstant(_coin)
GL_BUFFER_MAP_POINTER = _coin.GL_BUFFER_MAP_POINTER

_coin.GL_STREAM_DRAW_swigconstant(_coin)
GL_STREAM_DRAW = _coin.GL_STREAM_DRAW

_coin.GL_STREAM_READ_swigconstant(_coin)
GL_STREAM_READ = _coin.GL_STREAM_READ

_coin.GL_STREAM_COPY_swigconstant(_coin)
GL_STREAM_COPY = _coin.GL_STREAM_COPY

_coin.GL_STATIC_DRAW_swigconstant(_coin)
GL_STATIC_DRAW = _coin.GL_STATIC_DRAW

_coin.GL_STATIC_READ_swigconstant(_coin)
GL_STATIC_READ = _coin.GL_STATIC_READ

_coin.GL_STATIC_COPY_swigconstant(_coin)
GL_STATIC_COPY = _coin.GL_STATIC_COPY

_coin.GL_DYNAMIC_DRAW_swigconstant(_coin)
GL_DYNAMIC_DRAW = _coin.GL_DYNAMIC_DRAW

_coin.GL_DYNAMIC_READ_swigconstant(_coin)
GL_DYNAMIC_READ = _coin.GL_DYNAMIC_READ

_coin.GL_DYNAMIC_COPY_swigconstant(_coin)
GL_DYNAMIC_COPY = _coin.GL_DYNAMIC_COPY

_coin.GL_REGISTER_COMBINERS_NV_swigconstant(_coin)
GL_REGISTER_COMBINERS_NV = _coin.GL_REGISTER_COMBINERS_NV

_coin.GL_COMBINER0_NV_swigconstant(_coin)
GL_COMBINER0_NV = _coin.GL_COMBINER0_NV

_coin.GL_COMBINER1_NV_swigconstant(_coin)
GL_COMBINER1_NV = _coin.GL_COMBINER1_NV

_coin.GL_COMBINER2_NV_swigconstant(_coin)
GL_COMBINER2_NV = _coin.GL_COMBINER2_NV

_coin.GL_COMBINER3_NV_swigconstant(_coin)
GL_COMBINER3_NV = _coin.GL_COMBINER3_NV

_coin.GL_COMBINER4_NV_swigconstant(_coin)
GL_COMBINER4_NV = _coin.GL_COMBINER4_NV

_coin.GL_COMBINER5_NV_swigconstant(_coin)
GL_COMBINER5_NV = _coin.GL_COMBINER5_NV

_coin.GL_COMBINER6_NV_swigconstant(_coin)
GL_COMBINER6_NV = _coin.GL_COMBINER6_NV

_coin.GL_COMBINER7_NV_swigconstant(_coin)
GL_COMBINER7_NV = _coin.GL_COMBINER7_NV

_coin.GL_VARIABLE_A_NV_swigconstant(_coin)
GL_VARIABLE_A_NV = _coin.GL_VARIABLE_A_NV

_coin.GL_VARIABLE_B_NV_swigconstant(_coin)
GL_VARIABLE_B_NV = _coin.GL_VARIABLE_B_NV

_coin.GL_VARIABLE_C_NV_swigconstant(_coin)
GL_VARIABLE_C_NV = _coin.GL_VARIABLE_C_NV

_coin.GL_VARIABLE_D_NV_swigconstant(_coin)
GL_VARIABLE_D_NV = _coin.GL_VARIABLE_D_NV

_coin.GL_VARIABLE_E_NV_swigconstant(_coin)
GL_VARIABLE_E_NV = _coin.GL_VARIABLE_E_NV

_coin.GL_VARIABLE_F_NV_swigconstant(_coin)
GL_VARIABLE_F_NV = _coin.GL_VARIABLE_F_NV

_coin.GL_VARIABLE_G_NV_swigconstant(_coin)
GL_VARIABLE_G_NV = _coin.GL_VARIABLE_G_NV

_coin.GL_CONSTANT_COLOR0_NV_swigconstant(_coin)
GL_CONSTANT_COLOR0_NV = _coin.GL_CONSTANT_COLOR0_NV

_coin.GL_CONSTANT_COLOR1_NV_swigconstant(_coin)
GL_CONSTANT_COLOR1_NV = _coin.GL_CONSTANT_COLOR1_NV

_coin.GL_PRIMARY_COLOR_NV_swigconstant(_coin)
GL_PRIMARY_COLOR_NV = _coin.GL_PRIMARY_COLOR_NV

_coin.GL_SECONDARY_COLOR_NV_swigconstant(_coin)
GL_SECONDARY_COLOR_NV = _coin.GL_SECONDARY_COLOR_NV

_coin.GL_SPARE0_NV_swigconstant(_coin)
GL_SPARE0_NV = _coin.GL_SPARE0_NV

_coin.GL_SPARE1_NV_swigconstant(_coin)
GL_SPARE1_NV = _coin.GL_SPARE1_NV

_coin.GL_UNSIGNED_IDENTITY_NV_swigconstant(_coin)
GL_UNSIGNED_IDENTITY_NV = _coin.GL_UNSIGNED_IDENTITY_NV

_coin.GL_UNSIGNED_INVERT_NV_swigconstant(_coin)
GL_UNSIGNED_INVERT_NV = _coin.GL_UNSIGNED_INVERT_NV

_coin.GL_EXPAND_NORMAL_NV_swigconstant(_coin)
GL_EXPAND_NORMAL_NV = _coin.GL_EXPAND_NORMAL_NV

_coin.GL_EXPAND_NEGATE_NV_swigconstant(_coin)
GL_EXPAND_NEGATE_NV = _coin.GL_EXPAND_NEGATE_NV

_coin.GL_HALF_BIAS_NORMAL_NV_swigconstant(_coin)
GL_HALF_BIAS_NORMAL_NV = _coin.GL_HALF_BIAS_NORMAL_NV

_coin.GL_HALF_BIAS_NEGATE_NV_swigconstant(_coin)
GL_HALF_BIAS_NEGATE_NV = _coin.GL_HALF_BIAS_NEGATE_NV

_coin.GL_SIGNED_IDENTITY_NV_swigconstant(_coin)
GL_SIGNED_IDENTITY_NV = _coin.GL_SIGNED_IDENTITY_NV

_coin.GL_SIGNED_NEGATE_NV_swigconstant(_coin)
GL_SIGNED_NEGATE_NV = _coin.GL_SIGNED_NEGATE_NV

_coin.GL_E_TIMES_F_NV_swigconstant(_coin)
GL_E_TIMES_F_NV = _coin.GL_E_TIMES_F_NV

_coin.GL_SPARE0_PLUS_SECONDARY_COLOR_NV_swigconstant(_coin)
GL_SPARE0_PLUS_SECONDARY_COLOR_NV = _coin.GL_SPARE0_PLUS_SECONDARY_COLOR_NV

_coin.GL_SCALE_BY_TWO_NV_swigconstant(_coin)
GL_SCALE_BY_TWO_NV = _coin.GL_SCALE_BY_TWO_NV

_coin.GL_SCALE_BY_FOUR_NV_swigconstant(_coin)
GL_SCALE_BY_FOUR_NV = _coin.GL_SCALE_BY_FOUR_NV

_coin.GL_SCALE_BY_ONE_HALF_NV_swigconstant(_coin)
GL_SCALE_BY_ONE_HALF_NV = _coin.GL_SCALE_BY_ONE_HALF_NV

_coin.GL_BIAS_BY_NEGATIVE_ONE_HALF_NV_swigconstant(_coin)
GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = _coin.GL_BIAS_BY_NEGATIVE_ONE_HALF_NV

_coin.GL_DISCARD_NV_swigconstant(_coin)
GL_DISCARD_NV = _coin.GL_DISCARD_NV

_coin.GL_COMBINER_INPUT_NV_swigconstant(_coin)
GL_COMBINER_INPUT_NV = _coin.GL_COMBINER_INPUT_NV

_coin.GL_COMBINER_MAPPING_NV_swigconstant(_coin)
GL_COMBINER_MAPPING_NV = _coin.GL_COMBINER_MAPPING_NV

_coin.GL_COMBINER_COMPONENT_USAGE_NV_swigconstant(_coin)
GL_COMBINER_COMPONENT_USAGE_NV = _coin.GL_COMBINER_COMPONENT_USAGE_NV

_coin.GL_COMBINER_AB_DOT_PRODUCT_NV_swigconstant(_coin)
GL_COMBINER_AB_DOT_PRODUCT_NV = _coin.GL_COMBINER_AB_DOT_PRODUCT_NV

_coin.GL_COMBINER_CD_DOT_PRODUCT_NV_swigconstant(_coin)
GL_COMBINER_CD_DOT_PRODUCT_NV = _coin.GL_COMBINER_CD_DOT_PRODUCT_NV

_coin.GL_COMBINER_MUX_SUM_NV_swigconstant(_coin)
GL_COMBINER_MUX_SUM_NV = _coin.GL_COMBINER_MUX_SUM_NV

_coin.GL_COMBINER_SCALE_NV_swigconstant(_coin)
GL_COMBINER_SCALE_NV = _coin.GL_COMBINER_SCALE_NV

_coin.GL_COMBINER_BIAS_NV_swigconstant(_coin)
GL_COMBINER_BIAS_NV = _coin.GL_COMBINER_BIAS_NV

_coin.GL_COMBINER_AB_OUTPUT_NV_swigconstant(_coin)
GL_COMBINER_AB_OUTPUT_NV = _coin.GL_COMBINER_AB_OUTPUT_NV

_coin.GL_COMBINER_CD_OUTPUT_NV_swigconstant(_coin)
GL_COMBINER_CD_OUTPUT_NV = _coin.GL_COMBINER_CD_OUTPUT_NV

_coin.GL_COMBINER_SUM_OUTPUT_NV_swigconstant(_coin)
GL_COMBINER_SUM_OUTPUT_NV = _coin.GL_COMBINER_SUM_OUTPUT_NV

_coin.GL_MAX_GENERAL_COMBINERS_NV_swigconstant(_coin)
GL_MAX_GENERAL_COMBINERS_NV = _coin.GL_MAX_GENERAL_COMBINERS_NV

_coin.GL_NUM_GENERAL_COMBINERS_NV_swigconstant(_coin)
GL_NUM_GENERAL_COMBINERS_NV = _coin.GL_NUM_GENERAL_COMBINERS_NV

_coin.GL_COLOR_SUM_CLAMP_NV_swigconstant(_coin)
GL_COLOR_SUM_CLAMP_NV = _coin.GL_COLOR_SUM_CLAMP_NV

_coin.GL_TEXTURE_RECTANGLE_NV_swigconstant(_coin)
GL_TEXTURE_RECTANGLE_NV = _coin.GL_TEXTURE_RECTANGLE_NV

_coin.GL_TEXTURE_BINDING_RECTANGLE_NV_swigconstant(_coin)
GL_TEXTURE_BINDING_RECTANGLE_NV = _coin.GL_TEXTURE_BINDING_RECTANGLE_NV

_coin.GL_PROXY_TEXTURE_RECTANGLE_NV_swigconstant(_coin)
GL_PROXY_TEXTURE_RECTANGLE_NV = _coin.GL_PROXY_TEXTURE_RECTANGLE_NV

_coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_NV_swigconstant(_coin)
GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = _coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_NV

_coin.GL_TEXTURE_RECTANGLE_EXT_swigconstant(_coin)
GL_TEXTURE_RECTANGLE_EXT = _coin.GL_TEXTURE_RECTANGLE_EXT

_coin.GL_TEXTURE_BINDING_RECTANGLE_EXT_swigconstant(_coin)
GL_TEXTURE_BINDING_RECTANGLE_EXT = _coin.GL_TEXTURE_BINDING_RECTANGLE_EXT

_coin.GL_PROXY_TEXTURE_RECTANGLE_EXT_swigconstant(_coin)
GL_PROXY_TEXTURE_RECTANGLE_EXT = _coin.GL_PROXY_TEXTURE_RECTANGLE_EXT

_coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT_swigconstant(_coin)
GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = _coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT

_coin.GL_OFFSET_TEXTURE_RECTANGLE_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_RECTANGLE_NV = _coin.GL_OFFSET_TEXTURE_RECTANGLE_NV

_coin.GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = _coin.GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV

_coin.GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV_swigconstant(_coin)
GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = _coin.GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV

_coin.GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV_swigconstant(_coin)
GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = _coin.GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV

_coin.GL_UNSIGNED_INT_S8_S8_8_8_NV_swigconstant(_coin)
GL_UNSIGNED_INT_S8_S8_8_8_NV = _coin.GL_UNSIGNED_INT_S8_S8_8_8_NV

_coin.GL_UNSIGNED_INT_8_8_S8_S8_REV_NV_swigconstant(_coin)
GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = _coin.GL_UNSIGNED_INT_8_8_S8_S8_REV_NV

_coin.GL_DSDT_MAG_INTENSITY_NV_swigconstant(_coin)
GL_DSDT_MAG_INTENSITY_NV = _coin.GL_DSDT_MAG_INTENSITY_NV

_coin.GL_SHADER_CONSISTENT_NV_swigconstant(_coin)
GL_SHADER_CONSISTENT_NV = _coin.GL_SHADER_CONSISTENT_NV

_coin.GL_TEXTURE_SHADER_NV_swigconstant(_coin)
GL_TEXTURE_SHADER_NV = _coin.GL_TEXTURE_SHADER_NV

_coin.GL_SHADER_OPERATION_NV_swigconstant(_coin)
GL_SHADER_OPERATION_NV = _coin.GL_SHADER_OPERATION_NV

_coin.GL_CULL_MODES_NV_swigconstant(_coin)
GL_CULL_MODES_NV = _coin.GL_CULL_MODES_NV

_coin.GL_OFFSET_TEXTURE_MATRIX_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_MATRIX_NV = _coin.GL_OFFSET_TEXTURE_MATRIX_NV

_coin.GL_OFFSET_TEXTURE_SCALE_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_SCALE_NV = _coin.GL_OFFSET_TEXTURE_SCALE_NV

_coin.GL_OFFSET_TEXTURE_BIAS_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_BIAS_NV = _coin.GL_OFFSET_TEXTURE_BIAS_NV

_coin.GL_OFFSET_TEXTURE_2D_MATRIX_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_2D_MATRIX_NV = _coin.GL_OFFSET_TEXTURE_2D_MATRIX_NV

_coin.GL_OFFSET_TEXTURE_2D_SCALE_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_2D_SCALE_NV = _coin.GL_OFFSET_TEXTURE_2D_SCALE_NV

_coin.GL_OFFSET_TEXTURE_2D_BIAS_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_2D_BIAS_NV = _coin.GL_OFFSET_TEXTURE_2D_BIAS_NV

_coin.GL_PREVIOUS_TEXTURE_INPUT_NV_swigconstant(_coin)
GL_PREVIOUS_TEXTURE_INPUT_NV = _coin.GL_PREVIOUS_TEXTURE_INPUT_NV

_coin.GL_CONST_EYE_NV_swigconstant(_coin)
GL_CONST_EYE_NV = _coin.GL_CONST_EYE_NV

_coin.GL_PASS_THROUGH_NV_swigconstant(_coin)
GL_PASS_THROUGH_NV = _coin.GL_PASS_THROUGH_NV

_coin.GL_CULL_FRAGMENT_NV_swigconstant(_coin)
GL_CULL_FRAGMENT_NV = _coin.GL_CULL_FRAGMENT_NV

_coin.GL_OFFSET_TEXTURE_2D_NV_swigconstant(_coin)
GL_OFFSET_TEXTURE_2D_NV = _coin.GL_OFFSET_TEXTURE_2D_NV

_coin.GL_DEPENDENT_AR_TEXTURE_2D_NV_swigconstant(_coin)
GL_DEPENDENT_AR_TEXTURE_2D_NV = _coin.GL_DEPENDENT_AR_TEXTURE_2D_NV

_coin.GL_DEPENDENT_GB_TEXTURE_2D_NV_swigconstant(_coin)
GL_DEPENDENT_GB_TEXTURE_2D_NV = _coin.GL_DEPENDENT_GB_TEXTURE_2D_NV

_coin.GL_DOT_PRODUCT_NV_swigconstant(_coin)
GL_DOT_PRODUCT_NV = _coin.GL_DOT_PRODUCT_NV

_coin.GL_DOT_PRODUCT_DEPTH_REPLACE_NV_swigconstant(_coin)
GL_DOT_PRODUCT_DEPTH_REPLACE_NV = _coin.GL_DOT_PRODUCT_DEPTH_REPLACE_NV

_coin.GL_DOT_PRODUCT_TEXTURE_2D_NV_swigconstant(_coin)
GL_DOT_PRODUCT_TEXTURE_2D_NV = _coin.GL_DOT_PRODUCT_TEXTURE_2D_NV

_coin.GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV_swigconstant(_coin)
GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV

_coin.GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV_swigconstant(_coin)
GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV

_coin.GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV_swigconstant(_coin)
GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV

_coin.GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV_swigconstant(_coin)
GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV

_coin.GL_HILO_NV_swigconstant(_coin)
GL_HILO_NV = _coin.GL_HILO_NV

_coin.GL_DSDT_NV_swigconstant(_coin)
GL_DSDT_NV = _coin.GL_DSDT_NV

_coin.GL_DSDT_MAG_NV_swigconstant(_coin)
GL_DSDT_MAG_NV = _coin.GL_DSDT_MAG_NV

_coin.GL_DSDT_MAG_VIB_NV_swigconstant(_coin)
GL_DSDT_MAG_VIB_NV = _coin.GL_DSDT_MAG_VIB_NV

_coin.GL_HILO16_NV_swigconstant(_coin)
GL_HILO16_NV = _coin.GL_HILO16_NV

_coin.GL_SIGNED_HILO_NV_swigconstant(_coin)
GL_SIGNED_HILO_NV = _coin.GL_SIGNED_HILO_NV

_coin.GL_SIGNED_HILO16_NV_swigconstant(_coin)
GL_SIGNED_HILO16_NV = _coin.GL_SIGNED_HILO16_NV

_coin.GL_SIGNED_RGBA_NV_swigconstant(_coin)
GL_SIGNED_RGBA_NV = _coin.GL_SIGNED_RGBA_NV

_coin.GL_SIGNED_RGBA8_NV_swigconstant(_coin)
GL_SIGNED_RGBA8_NV = _coin.GL_SIGNED_RGBA8_NV

_coin.GL_SIGNED_RGB_NV_swigconstant(_coin)
GL_SIGNED_RGB_NV = _coin.GL_SIGNED_RGB_NV

_coin.GL_SIGNED_RGB8_NV_swigconstant(_coin)
GL_SIGNED_RGB8_NV = _coin.GL_SIGNED_RGB8_NV

_coin.GL_SIGNED_LUMINANCE_NV_swigconstant(_coin)
GL_SIGNED_LUMINANCE_NV = _coin.GL_SIGNED_LUMINANCE_NV

_coin.GL_SIGNED_LUMINANCE8_NV_swigconstant(_coin)
GL_SIGNED_LUMINANCE8_NV = _coin.GL_SIGNED_LUMINANCE8_NV

_coin.GL_SIGNED_LUMINANCE_ALPHA_NV_swigconstant(_coin)
GL_SIGNED_LUMINANCE_ALPHA_NV = _coin.GL_SIGNED_LUMINANCE_ALPHA_NV

_coin.GL_SIGNED_LUMINANCE8_ALPHA8_NV_swigconstant(_coin)
GL_SIGNED_LUMINANCE8_ALPHA8_NV = _coin.GL_SIGNED_LUMINANCE8_ALPHA8_NV

_coin.GL_SIGNED_ALPHA_NV_swigconstant(_coin)
GL_SIGNED_ALPHA_NV = _coin.GL_SIGNED_ALPHA_NV

_coin.GL_SIGNED_ALPHA8_NV_swigconstant(_coin)
GL_SIGNED_ALPHA8_NV = _coin.GL_SIGNED_ALPHA8_NV

_coin.GL_SIGNED_INTENSITY_NV_swigconstant(_coin)
GL_SIGNED_INTENSITY_NV = _coin.GL_SIGNED_INTENSITY_NV

_coin.GL_SIGNED_INTENSITY8_NV_swigconstant(_coin)
GL_SIGNED_INTENSITY8_NV = _coin.GL_SIGNED_INTENSITY8_NV

_coin.GL_DSDT8_NV_swigconstant(_coin)
GL_DSDT8_NV = _coin.GL_DSDT8_NV

_coin.GL_DSDT8_MAG8_NV_swigconstant(_coin)
GL_DSDT8_MAG8_NV = _coin.GL_DSDT8_MAG8_NV

_coin.GL_DSDT8_MAG8_INTENSITY8_NV_swigconstant(_coin)
GL_DSDT8_MAG8_INTENSITY8_NV = _coin.GL_DSDT8_MAG8_INTENSITY8_NV

_coin.GL_SIGNED_RGB_UNSIGNED_ALPHA_NV_swigconstant(_coin)
GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = _coin.GL_SIGNED_RGB_UNSIGNED_ALPHA_NV

_coin.GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV_swigconstant(_coin)
GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = _coin.GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV

_coin.GL_HI_SCALE_NV_swigconstant(_coin)
GL_HI_SCALE_NV = _coin.GL_HI_SCALE_NV

_coin.GL_LO_SCALE_NV_swigconstant(_coin)
GL_LO_SCALE_NV = _coin.GL_LO_SCALE_NV

_coin.GL_DS_SCALE_NV_swigconstant(_coin)
GL_DS_SCALE_NV = _coin.GL_DS_SCALE_NV

_coin.GL_DT_SCALE_NV_swigconstant(_coin)
GL_DT_SCALE_NV = _coin.GL_DT_SCALE_NV

_coin.GL_MAGNITUDE_SCALE_NV_swigconstant(_coin)
GL_MAGNITUDE_SCALE_NV = _coin.GL_MAGNITUDE_SCALE_NV

_coin.GL_VIBRANCE_SCALE_NV_swigconstant(_coin)
GL_VIBRANCE_SCALE_NV = _coin.GL_VIBRANCE_SCALE_NV

_coin.GL_HI_BIAS_NV_swigconstant(_coin)
GL_HI_BIAS_NV = _coin.GL_HI_BIAS_NV

_coin.GL_LO_BIAS_NV_swigconstant(_coin)
GL_LO_BIAS_NV = _coin.GL_LO_BIAS_NV

_coin.GL_DS_BIAS_NV_swigconstant(_coin)
GL_DS_BIAS_NV = _coin.GL_DS_BIAS_NV

_coin.GL_DT_BIAS_NV_swigconstant(_coin)
GL_DT_BIAS_NV = _coin.GL_DT_BIAS_NV

_coin.GL_MAGNITUDE_BIAS_NV_swigconstant(_coin)
GL_MAGNITUDE_BIAS_NV = _coin.GL_MAGNITUDE_BIAS_NV

_coin.GL_VIBRANCE_BIAS_NV_swigconstant(_coin)
GL_VIBRANCE_BIAS_NV = _coin.GL_VIBRANCE_BIAS_NV

_coin.GL_TEXTURE_BORDER_VALUES_NV_swigconstant(_coin)
GL_TEXTURE_BORDER_VALUES_NV = _coin.GL_TEXTURE_BORDER_VALUES_NV

_coin.GL_TEXTURE_HI_SIZE_NV_swigconstant(_coin)
GL_TEXTURE_HI_SIZE_NV = _coin.GL_TEXTURE_HI_SIZE_NV

_coin.GL_TEXTURE_LO_SIZE_NV_swigconstant(_coin)
GL_TEXTURE_LO_SIZE_NV = _coin.GL_TEXTURE_LO_SIZE_NV

_coin.GL_TEXTURE_DS_SIZE_NV_swigconstant(_coin)
GL_TEXTURE_DS_SIZE_NV = _coin.GL_TEXTURE_DS_SIZE_NV

_coin.GL_TEXTURE_DT_SIZE_NV_swigconstant(_coin)
GL_TEXTURE_DT_SIZE_NV = _coin.GL_TEXTURE_DT_SIZE_NV

_coin.GL_TEXTURE_MAG_SIZE_NV_swigconstant(_coin)
GL_TEXTURE_MAG_SIZE_NV = _coin.GL_TEXTURE_MAG_SIZE_NV

_coin.GL_NORMAL_MAP_swigconstant(_coin)
GL_NORMAL_MAP = _coin.GL_NORMAL_MAP

_coin.GL_REFLECTION_MAP_swigconstant(_coin)
GL_REFLECTION_MAP = _coin.GL_REFLECTION_MAP

_coin.GL_TEXTURE_CUBE_MAP_swigconstant(_coin)
GL_TEXTURE_CUBE_MAP = _coin.GL_TEXTURE_CUBE_MAP

_coin.GL_TEXTURE_BINDING_CUBE_MAP_swigconstant(_coin)
GL_TEXTURE_BINDING_CUBE_MAP = _coin.GL_TEXTURE_BINDING_CUBE_MAP

_coin.GL_TEXTURE_CUBE_MAP_POSITIVE_X_swigconstant(_coin)
GL_TEXTURE_CUBE_MAP_POSITIVE_X = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_X

_coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_X_swigconstant(_coin)
GL_TEXTURE_CUBE_MAP_NEGATIVE_X = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_X

_coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Y_swigconstant(_coin)
GL_TEXTURE_CUBE_MAP_POSITIVE_Y = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Y

_coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_swigconstant(_coin)
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y

_coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Z_swigconstant(_coin)
GL_TEXTURE_CUBE_MAP_POSITIVE_Z = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Z

_coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_swigconstant(_coin)
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z

_coin.GL_MAX_CUBE_MAP_TEXTURE_SIZE_swigconstant(_coin)
GL_MAX_CUBE_MAP_TEXTURE_SIZE = _coin.GL_MAX_CUBE_MAP_TEXTURE_SIZE

_coin.GL_COMBINE_swigconstant(_coin)
GL_COMBINE = _coin.GL_COMBINE

_coin.GL_COMBINE_RGB_swigconstant(_coin)
GL_COMBINE_RGB = _coin.GL_COMBINE_RGB

_coin.GL_COMBINE_ALPHA_swigconstant(_coin)
GL_COMBINE_ALPHA = _coin.GL_COMBINE_ALPHA

_coin.GL_RGB_SCALE_swigconstant(_coin)
GL_RGB_SCALE = _coin.GL_RGB_SCALE

_coin.GL_ADD_SIGNED_swigconstant(_coin)
GL_ADD_SIGNED = _coin.GL_ADD_SIGNED

_coin.GL_INTERPOLATE_swigconstant(_coin)
GL_INTERPOLATE = _coin.GL_INTERPOLATE

_coin.GL_CONSTANT_swigconstant(_coin)
GL_CONSTANT = _coin.GL_CONSTANT

_coin.GL_PRIMARY_COLOR_swigconstant(_coin)
GL_PRIMARY_COLOR = _coin.GL_PRIMARY_COLOR

_coin.GL_PREVIOUS_swigconstant(_coin)
GL_PREVIOUS = _coin.GL_PREVIOUS

_coin.GL_SOURCE0_RGB_swigconstant(_coin)
GL_SOURCE0_RGB = _coin.GL_SOURCE0_RGB

_coin.GL_SOURCE1_RGB_swigconstant(_coin)
GL_SOURCE1_RGB = _coin.GL_SOURCE1_RGB

_coin.GL_SOURCE2_RGB_swigconstant(_coin)
GL_SOURCE2_RGB = _coin.GL_SOURCE2_RGB

_coin.GL_SOURCE0_ALPHA_swigconstant(_coin)
GL_SOURCE0_ALPHA = _coin.GL_SOURCE0_ALPHA

_coin.GL_SOURCE1_ALPHA_swigconstant(_coin)
GL_SOURCE1_ALPHA = _coin.GL_SOURCE1_ALPHA

_coin.GL_SOURCE2_ALPHA_swigconstant(_coin)
GL_SOURCE2_ALPHA = _coin.GL_SOURCE2_ALPHA

_coin.GL_OPERAND0_RGB_swigconstant(_coin)
GL_OPERAND0_RGB = _coin.GL_OPERAND0_RGB

_coin.GL_OPERAND1_RGB_swigconstant(_coin)
GL_OPERAND1_RGB = _coin.GL_OPERAND1_RGB

_coin.GL_OPERAND2_RGB_swigconstant(_coin)
GL_OPERAND2_RGB = _coin.GL_OPERAND2_RGB

_coin.GL_OPERAND0_ALPHA_swigconstant(_coin)
GL_OPERAND0_ALPHA = _coin.GL_OPERAND0_ALPHA

_coin.GL_OPERAND1_ALPHA_swigconstant(_coin)
GL_OPERAND1_ALPHA = _coin.GL_OPERAND1_ALPHA

_coin.GL_OPERAND2_ALPHA_swigconstant(_coin)
GL_OPERAND2_ALPHA = _coin.GL_OPERAND2_ALPHA

_coin.GL_SUBTRACT_swigconstant(_coin)
GL_SUBTRACT = _coin.GL_SUBTRACT

_coin.GL_DOT3_RGB_swigconstant(_coin)
GL_DOT3_RGB = _coin.GL_DOT3_RGB

_coin.GL_DOT3_RGBA_swigconstant(_coin)
GL_DOT3_RGBA = _coin.GL_DOT3_RGBA

_coin.GL_GENERATE_MIPMAP_SGIS_swigconstant(_coin)
GL_GENERATE_MIPMAP_SGIS = _coin.GL_GENERATE_MIPMAP_SGIS

_coin.GL_GENERATE_MIPMAP_HINT_SGIS_swigconstant(_coin)
GL_GENERATE_MIPMAP_HINT_SGIS = _coin.GL_GENERATE_MIPMAP_HINT_SGIS

_coin.GL_FRAGMENT_PROGRAM_ARB_swigconstant(_coin)
GL_FRAGMENT_PROGRAM_ARB = _coin.GL_FRAGMENT_PROGRAM_ARB

_coin.GL_PROGRAM_FORMAT_ASCII_ARB_swigconstant(_coin)
GL_PROGRAM_FORMAT_ASCII_ARB = _coin.GL_PROGRAM_FORMAT_ASCII_ARB

_coin.GL_PROGRAM_LENGTH_ARB_swigconstant(_coin)
GL_PROGRAM_LENGTH_ARB = _coin.GL_PROGRAM_LENGTH_ARB

_coin.GL_PROGRAM_FORMAT_ARB_swigconstant(_coin)
GL_PROGRAM_FORMAT_ARB = _coin.GL_PROGRAM_FORMAT_ARB

_coin.GL_PROGRAM_BINDING_ARB_swigconstant(_coin)
GL_PROGRAM_BINDING_ARB = _coin.GL_PROGRAM_BINDING_ARB

_coin.GL_PROGRAM_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_PROGRAM_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_INSTRUCTIONS_ARB

_coin.GL_MAX_PROGRAM_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_INSTRUCTIONS_ARB

_coin.GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB

_coin.GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB

_coin.GL_PROGRAM_TEMPORARIES_ARB_swigconstant(_coin)
GL_PROGRAM_TEMPORARIES_ARB = _coin.GL_PROGRAM_TEMPORARIES_ARB

_coin.GL_MAX_PROGRAM_TEMPORARIES_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_TEMPORARIES_ARB = _coin.GL_MAX_PROGRAM_TEMPORARIES_ARB

_coin.GL_PROGRAM_NATIVE_TEMPORARIES_ARB_swigconstant(_coin)
GL_PROGRAM_NATIVE_TEMPORARIES_ARB = _coin.GL_PROGRAM_NATIVE_TEMPORARIES_ARB

_coin.GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB

_coin.GL_PROGRAM_PARAMETERS_ARB_swigconstant(_coin)
GL_PROGRAM_PARAMETERS_ARB = _coin.GL_PROGRAM_PARAMETERS_ARB

_coin.GL_MAX_PROGRAM_PARAMETERS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_PARAMETERS_ARB

_coin.GL_PROGRAM_NATIVE_PARAMETERS_ARB_swigconstant(_coin)
GL_PROGRAM_NATIVE_PARAMETERS_ARB = _coin.GL_PROGRAM_NATIVE_PARAMETERS_ARB

_coin.GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB

_coin.GL_PROGRAM_ATTRIBS_ARB_swigconstant(_coin)
GL_PROGRAM_ATTRIBS_ARB = _coin.GL_PROGRAM_ATTRIBS_ARB

_coin.GL_MAX_PROGRAM_ATTRIBS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_ATTRIBS_ARB = _coin.GL_MAX_PROGRAM_ATTRIBS_ARB

_coin.GL_PROGRAM_NATIVE_ATTRIBS_ARB_swigconstant(_coin)
GL_PROGRAM_NATIVE_ATTRIBS_ARB = _coin.GL_PROGRAM_NATIVE_ATTRIBS_ARB

_coin.GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB

_coin.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB

_coin.GL_MAX_PROGRAM_ENV_PARAMETERS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_ENV_PARAMETERS_ARB

_coin.GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB_swigconstant(_coin)
GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = _coin.GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB

_coin.GL_PROGRAM_ALU_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_PROGRAM_ALU_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_ALU_INSTRUCTIONS_ARB

_coin.GL_PROGRAM_TEX_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_PROGRAM_TEX_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_TEX_INSTRUCTIONS_ARB

_coin.GL_PROGRAM_TEX_INDIRECTIONS_ARB_swigconstant(_coin)
GL_PROGRAM_TEX_INDIRECTIONS_ARB = _coin.GL_PROGRAM_TEX_INDIRECTIONS_ARB

_coin.GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB

_coin.GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB

_coin.GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB_swigconstant(_coin)
GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = _coin.GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB

_coin.GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB

_coin.GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB

_coin.GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = _coin.GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB

_coin.GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB

_coin.GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB

_coin.GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB

_coin.GL_PROGRAM_STRING_ARB_swigconstant(_coin)
GL_PROGRAM_STRING_ARB = _coin.GL_PROGRAM_STRING_ARB

_coin.GL_PROGRAM_ERROR_POSITION_ARB_swigconstant(_coin)
GL_PROGRAM_ERROR_POSITION_ARB = _coin.GL_PROGRAM_ERROR_POSITION_ARB

_coin.GL_CURRENT_MATRIX_ARB_swigconstant(_coin)
GL_CURRENT_MATRIX_ARB = _coin.GL_CURRENT_MATRIX_ARB

_coin.GL_TRANSPOSE_CURRENT_MATRIX_ARB_swigconstant(_coin)
GL_TRANSPOSE_CURRENT_MATRIX_ARB = _coin.GL_TRANSPOSE_CURRENT_MATRIX_ARB

_coin.GL_CURRENT_MATRIX_STACK_DEPTH_ARB_swigconstant(_coin)
GL_CURRENT_MATRIX_STACK_DEPTH_ARB = _coin.GL_CURRENT_MATRIX_STACK_DEPTH_ARB

_coin.GL_MAX_PROGRAM_MATRICES_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_MATRICES_ARB = _coin.GL_MAX_PROGRAM_MATRICES_ARB

_coin.GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = _coin.GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB

_coin.GL_MAX_TEXTURE_COORDS_ARB_swigconstant(_coin)
GL_MAX_TEXTURE_COORDS_ARB = _coin.GL_MAX_TEXTURE_COORDS_ARB

_coin.GL_MAX_TEXTURE_IMAGE_UNITS_ARB_swigconstant(_coin)
GL_MAX_TEXTURE_IMAGE_UNITS_ARB = _coin.GL_MAX_TEXTURE_IMAGE_UNITS_ARB

_coin.GL_PROGRAM_ERROR_STRING_ARB_swigconstant(_coin)
GL_PROGRAM_ERROR_STRING_ARB = _coin.GL_PROGRAM_ERROR_STRING_ARB

_coin.GL_MATRIX0_ARB_swigconstant(_coin)
GL_MATRIX0_ARB = _coin.GL_MATRIX0_ARB

_coin.GL_MATRIX1_ARB_swigconstant(_coin)
GL_MATRIX1_ARB = _coin.GL_MATRIX1_ARB

_coin.GL_MATRIX2_ARB_swigconstant(_coin)
GL_MATRIX2_ARB = _coin.GL_MATRIX2_ARB

_coin.GL_MATRIX3_ARB_swigconstant(_coin)
GL_MATRIX3_ARB = _coin.GL_MATRIX3_ARB

_coin.GL_MATRIX4_ARB_swigconstant(_coin)
GL_MATRIX4_ARB = _coin.GL_MATRIX4_ARB

_coin.GL_MATRIX5_ARB_swigconstant(_coin)
GL_MATRIX5_ARB = _coin.GL_MATRIX5_ARB

_coin.GL_MATRIX6_ARB_swigconstant(_coin)
GL_MATRIX6_ARB = _coin.GL_MATRIX6_ARB

_coin.GL_MATRIX7_ARB_swigconstant(_coin)
GL_MATRIX7_ARB = _coin.GL_MATRIX7_ARB

_coin.GL_MATRIX8_ARB_swigconstant(_coin)
GL_MATRIX8_ARB = _coin.GL_MATRIX8_ARB

_coin.GL_MATRIX9_ARB_swigconstant(_coin)
GL_MATRIX9_ARB = _coin.GL_MATRIX9_ARB

_coin.GL_MATRIX10_ARB_swigconstant(_coin)
GL_MATRIX10_ARB = _coin.GL_MATRIX10_ARB

_coin.GL_MATRIX11_ARB_swigconstant(_coin)
GL_MATRIX11_ARB = _coin.GL_MATRIX11_ARB

_coin.GL_MATRIX12_ARB_swigconstant(_coin)
GL_MATRIX12_ARB = _coin.GL_MATRIX12_ARB

_coin.GL_MATRIX13_ARB_swigconstant(_coin)
GL_MATRIX13_ARB = _coin.GL_MATRIX13_ARB

_coin.GL_MATRIX14_ARB_swigconstant(_coin)
GL_MATRIX14_ARB = _coin.GL_MATRIX14_ARB

_coin.GL_MATRIX15_ARB_swigconstant(_coin)
GL_MATRIX15_ARB = _coin.GL_MATRIX15_ARB

_coin.GL_MATRIX16_ARB_swigconstant(_coin)
GL_MATRIX16_ARB = _coin.GL_MATRIX16_ARB

_coin.GL_MATRIX17_ARB_swigconstant(_coin)
GL_MATRIX17_ARB = _coin.GL_MATRIX17_ARB

_coin.GL_MATRIX18_ARB_swigconstant(_coin)
GL_MATRIX18_ARB = _coin.GL_MATRIX18_ARB

_coin.GL_MATRIX19_ARB_swigconstant(_coin)
GL_MATRIX19_ARB = _coin.GL_MATRIX19_ARB

_coin.GL_MATRIX20_ARB_swigconstant(_coin)
GL_MATRIX20_ARB = _coin.GL_MATRIX20_ARB

_coin.GL_MATRIX21_ARB_swigconstant(_coin)
GL_MATRIX21_ARB = _coin.GL_MATRIX21_ARB

_coin.GL_MATRIX22_ARB_swigconstant(_coin)
GL_MATRIX22_ARB = _coin.GL_MATRIX22_ARB

_coin.GL_MATRIX23_ARB_swigconstant(_coin)
GL_MATRIX23_ARB = _coin.GL_MATRIX23_ARB

_coin.GL_MATRIX24_ARB_swigconstant(_coin)
GL_MATRIX24_ARB = _coin.GL_MATRIX24_ARB

_coin.GL_MATRIX25_ARB_swigconstant(_coin)
GL_MATRIX25_ARB = _coin.GL_MATRIX25_ARB

_coin.GL_MATRIX26_ARB_swigconstant(_coin)
GL_MATRIX26_ARB = _coin.GL_MATRIX26_ARB

_coin.GL_MATRIX27_ARB_swigconstant(_coin)
GL_MATRIX27_ARB = _coin.GL_MATRIX27_ARB

_coin.GL_MATRIX28_ARB_swigconstant(_coin)
GL_MATRIX28_ARB = _coin.GL_MATRIX28_ARB

_coin.GL_MATRIX29_ARB_swigconstant(_coin)
GL_MATRIX29_ARB = _coin.GL_MATRIX29_ARB

_coin.GL_MATRIX30_ARB_swigconstant(_coin)
GL_MATRIX30_ARB = _coin.GL_MATRIX30_ARB

_coin.GL_MATRIX31_ARB_swigconstant(_coin)
GL_MATRIX31_ARB = _coin.GL_MATRIX31_ARB

_coin.GL_VERTEX_PROGRAM_ARB_swigconstant(_coin)
GL_VERTEX_PROGRAM_ARB = _coin.GL_VERTEX_PROGRAM_ARB

_coin.GL_VERTEX_PROGRAM_POINT_SIZE_ARB_swigconstant(_coin)
GL_VERTEX_PROGRAM_POINT_SIZE_ARB = _coin.GL_VERTEX_PROGRAM_POINT_SIZE_ARB

_coin.GL_VERTEX_PROGRAM_TWO_SIDE_ARB_swigconstant(_coin)
GL_VERTEX_PROGRAM_TWO_SIDE_ARB = _coin.GL_VERTEX_PROGRAM_TWO_SIDE_ARB

_coin.GL_COLOR_SUM_ARB_swigconstant(_coin)
GL_COLOR_SUM_ARB = _coin.GL_COLOR_SUM_ARB

_coin.GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB_swigconstant(_coin)
GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB

_coin.GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB_swigconstant(_coin)
GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB

_coin.GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB_swigconstant(_coin)
GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB

_coin.GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB_swigconstant(_coin)
GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB

_coin.GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB_swigconstant(_coin)
GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB

_coin.GL_CURRENT_VERTEX_ATTRIB_ARB_swigconstant(_coin)
GL_CURRENT_VERTEX_ATTRIB_ARB = _coin.GL_CURRENT_VERTEX_ATTRIB_ARB

_coin.GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB_swigconstant(_coin)
GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB

_coin.GL_PROGRAM_ADDRESS_REGISTERS_ARB_swigconstant(_coin)
GL_PROGRAM_ADDRESS_REGISTERS_ARB = _coin.GL_PROGRAM_ADDRESS_REGISTERS_ARB

_coin.GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = _coin.GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB

_coin.GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB_swigconstant(_coin)
GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = _coin.GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB

_coin.GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB_swigconstant(_coin)
GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB

_coin.GL_MAX_VERTEX_ATTRIBS_ARB_swigconstant(_coin)
GL_MAX_VERTEX_ATTRIBS_ARB = _coin.GL_MAX_VERTEX_ATTRIBS_ARB

_coin.GL_VERTEX_SHADER_ARB_swigconstant(_coin)
GL_VERTEX_SHADER_ARB = _coin.GL_VERTEX_SHADER_ARB

_coin.GL_FRAGMENT_SHADER_ARB_swigconstant(_coin)
GL_FRAGMENT_SHADER_ARB = _coin.GL_FRAGMENT_SHADER_ARB

_coin.GL_OBJECT_ACTIVE_UNIFORMS_ARB_swigconstant(_coin)
GL_OBJECT_ACTIVE_UNIFORMS_ARB = _coin.GL_OBJECT_ACTIVE_UNIFORMS_ARB

_coin.GL_GEOMETRY_SHADER_EXT_swigconstant(_coin)
GL_GEOMETRY_SHADER_EXT = _coin.GL_GEOMETRY_SHADER_EXT

_coin.GL_GEOMETRY_VERTICES_OUT_EXT_swigconstant(_coin)
GL_GEOMETRY_VERTICES_OUT_EXT = _coin.GL_GEOMETRY_VERTICES_OUT_EXT

_coin.GL_GEOMETRY_INPUT_TYPE_EXT_swigconstant(_coin)
GL_GEOMETRY_INPUT_TYPE_EXT = _coin.GL_GEOMETRY_INPUT_TYPE_EXT

_coin.GL_GEOMETRY_OUTPUT_TYPE_EXT_swigconstant(_coin)
GL_GEOMETRY_OUTPUT_TYPE_EXT = _coin.GL_GEOMETRY_OUTPUT_TYPE_EXT

_coin.GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT_swigconstant(_coin)
GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = _coin.GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT

_coin.GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT_swigconstant(_coin)
GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT

_coin.GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT_swigconstant(_coin)
GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = _coin.GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT

_coin.GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT_swigconstant(_coin)
GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT

_coin.GL_MAX_VERTEX_VARYING_COMPONENTS_EXT_swigconstant(_coin)
GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = _coin.GL_MAX_VERTEX_VARYING_COMPONENTS_EXT

_coin.GL_MAX_VARYING_COMPONENTS_EXT_swigconstant(_coin)
GL_MAX_VARYING_COMPONENTS_EXT = _coin.GL_MAX_VARYING_COMPONENTS_EXT

_coin.GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT_swigconstant(_coin)
GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT

_coin.GL_INT_VEC2_ARB_swigconstant(_coin)
GL_INT_VEC2_ARB = _coin.GL_INT_VEC2_ARB

_coin.GL_INT_VEC3_ARB_swigconstant(_coin)
GL_INT_VEC3_ARB = _coin.GL_INT_VEC3_ARB

_coin.GL_INT_VEC4_ARB_swigconstant(_coin)
GL_INT_VEC4_ARB = _coin.GL_INT_VEC4_ARB

_coin.GL_FLOAT_VEC2_ARB_swigconstant(_coin)
GL_FLOAT_VEC2_ARB = _coin.GL_FLOAT_VEC2_ARB

_coin.GL_FLOAT_VEC3_ARB_swigconstant(_coin)
GL_FLOAT_VEC3_ARB = _coin.GL_FLOAT_VEC3_ARB

_coin.GL_FLOAT_VEC4_ARB_swigconstant(_coin)
GL_FLOAT_VEC4_ARB = _coin.GL_FLOAT_VEC4_ARB

_coin.GL_FLOAT_MAT2_ARB_swigconstant(_coin)
GL_FLOAT_MAT2_ARB = _coin.GL_FLOAT_MAT2_ARB

_coin.GL_FLOAT_MAT3_ARB_swigconstant(_coin)
GL_FLOAT_MAT3_ARB = _coin.GL_FLOAT_MAT3_ARB

_coin.GL_FLOAT_MAT4_ARB_swigconstant(_coin)
GL_FLOAT_MAT4_ARB = _coin.GL_FLOAT_MAT4_ARB

_coin.GL_SAMPLER_1D_ARB_swigconstant(_coin)
GL_SAMPLER_1D_ARB = _coin.GL_SAMPLER_1D_ARB

_coin.GL_SAMPLER_2D_ARB_swigconstant(_coin)
GL_SAMPLER_2D_ARB = _coin.GL_SAMPLER_2D_ARB

_coin.GL_SAMPLER_3D_ARB_swigconstant(_coin)
GL_SAMPLER_3D_ARB = _coin.GL_SAMPLER_3D_ARB

_coin.GL_SAMPLER_CUBE_ARB_swigconstant(_coin)
GL_SAMPLER_CUBE_ARB = _coin.GL_SAMPLER_CUBE_ARB

_coin.GL_SAMPLER_1D_SHADOW_ARB_swigconstant(_coin)
GL_SAMPLER_1D_SHADOW_ARB = _coin.GL_SAMPLER_1D_SHADOW_ARB

_coin.GL_SAMPLER_2D_SHADOW_ARB_swigconstant(_coin)
GL_SAMPLER_2D_SHADOW_ARB = _coin.GL_SAMPLER_2D_SHADOW_ARB

_coin.GL_SAMPLER_2D_RECT_ARB_swigconstant(_coin)
GL_SAMPLER_2D_RECT_ARB = _coin.GL_SAMPLER_2D_RECT_ARB

_coin.GL_SAMPLER_2D_RECT_SHADOW_ARB_swigconstant(_coin)
GL_SAMPLER_2D_RECT_SHADOW_ARB = _coin.GL_SAMPLER_2D_RECT_SHADOW_ARB

_coin.GL_OBJECT_COMPILE_STATUS_ARB_swigconstant(_coin)
GL_OBJECT_COMPILE_STATUS_ARB = _coin.GL_OBJECT_COMPILE_STATUS_ARB

_coin.GL_OBJECT_INFO_LOG_LENGTH_ARB_swigconstant(_coin)
GL_OBJECT_INFO_LOG_LENGTH_ARB = _coin.GL_OBJECT_INFO_LOG_LENGTH_ARB

_coin.GL_OBJECT_LINK_STATUS_ARB_swigconstant(_coin)
GL_OBJECT_LINK_STATUS_ARB = _coin.GL_OBJECT_LINK_STATUS_ARB

_coin.GL_TEXTURE_MAX_ANISOTROPY_EXT_swigconstant(_coin)
GL_TEXTURE_MAX_ANISOTROPY_EXT = _coin.GL_TEXTURE_MAX_ANISOTROPY_EXT

_coin.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT_swigconstant(_coin)
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = _coin.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT

_coin.GL_SAMPLES_PASSED_swigconstant(_coin)
GL_SAMPLES_PASSED = _coin.GL_SAMPLES_PASSED

_coin.GL_QUERY_COUNTER_BITS_swigconstant(_coin)
GL_QUERY_COUNTER_BITS = _coin.GL_QUERY_COUNTER_BITS

_coin.GL_CURRENT_QUERY_swigconstant(_coin)
GL_CURRENT_QUERY = _coin.GL_CURRENT_QUERY

_coin.GL_QUERY_RESULT_swigconstant(_coin)
GL_QUERY_RESULT = _coin.GL_QUERY_RESULT

_coin.GL_QUERY_RESULT_AVAILABLE_swigconstant(_coin)
GL_QUERY_RESULT_AVAILABLE = _coin.GL_QUERY_RESULT_AVAILABLE

_coin.GL_CLIENT_PIXEL_STORE_BIT_swigconstant(_coin)
GL_CLIENT_PIXEL_STORE_BIT = _coin.GL_CLIENT_PIXEL_STORE_BIT

_coin.GL_CLIENT_VERTEX_ARRAY_BIT_swigconstant(_coin)
GL_CLIENT_VERTEX_ARRAY_BIT = _coin.GL_CLIENT_VERTEX_ARRAY_BIT

_coin.GL_CLIENT_ALL_ATTRIB_BITS_swigconstant(_coin)
GL_CLIENT_ALL_ATTRIB_BITS = _coin.GL_CLIENT_ALL_ATTRIB_BITS

_coin.GL_ALL_CLIENT_ATTRIB_BITS_swigconstant(_coin)
GL_ALL_CLIENT_ATTRIB_BITS = _coin.GL_ALL_CLIENT_ATTRIB_BITS

_coin.GL_INVALID_FRAMEBUFFER_OPERATION_EXT_swigconstant(_coin)
GL_INVALID_FRAMEBUFFER_OPERATION_EXT = _coin.GL_INVALID_FRAMEBUFFER_OPERATION_EXT

_coin.GL_MAX_RENDERBUFFER_SIZE_EXT_swigconstant(_coin)
GL_MAX_RENDERBUFFER_SIZE_EXT = _coin.GL_MAX_RENDERBUFFER_SIZE_EXT

_coin.GL_FRAMEBUFFER_BINDING_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_BINDING_EXT = _coin.GL_FRAMEBUFFER_BINDING_EXT

_coin.GL_RENDERBUFFER_BINDING_EXT_swigconstant(_coin)
GL_RENDERBUFFER_BINDING_EXT = _coin.GL_RENDERBUFFER_BINDING_EXT

_coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT

_coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT

_coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT

_coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT

_coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT

_coin.GL_FRAMEBUFFER_COMPLETE_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_COMPLETE_EXT = _coin.GL_FRAMEBUFFER_COMPLETE_EXT

_coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT

_coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT

_coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT

_coin.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT

_coin.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT

_coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT

_coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT

_coin.GL_FRAMEBUFFER_UNSUPPORTED_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_UNSUPPORTED_EXT = _coin.GL_FRAMEBUFFER_UNSUPPORTED_EXT

_coin.GL_MAX_COLOR_ATTACHMENTS_EXT_swigconstant(_coin)
GL_MAX_COLOR_ATTACHMENTS_EXT = _coin.GL_MAX_COLOR_ATTACHMENTS_EXT

_coin.GL_COLOR_ATTACHMENT0_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT0_EXT = _coin.GL_COLOR_ATTACHMENT0_EXT

_coin.GL_COLOR_ATTACHMENT1_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT1_EXT = _coin.GL_COLOR_ATTACHMENT1_EXT

_coin.GL_COLOR_ATTACHMENT2_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT2_EXT = _coin.GL_COLOR_ATTACHMENT2_EXT

_coin.GL_COLOR_ATTACHMENT3_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT3_EXT = _coin.GL_COLOR_ATTACHMENT3_EXT

_coin.GL_COLOR_ATTACHMENT4_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT4_EXT = _coin.GL_COLOR_ATTACHMENT4_EXT

_coin.GL_COLOR_ATTACHMENT5_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT5_EXT = _coin.GL_COLOR_ATTACHMENT5_EXT

_coin.GL_COLOR_ATTACHMENT6_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT6_EXT = _coin.GL_COLOR_ATTACHMENT6_EXT

_coin.GL_COLOR_ATTACHMENT7_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT7_EXT = _coin.GL_COLOR_ATTACHMENT7_EXT

_coin.GL_COLOR_ATTACHMENT8_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT8_EXT = _coin.GL_COLOR_ATTACHMENT8_EXT

_coin.GL_COLOR_ATTACHMENT9_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT9_EXT = _coin.GL_COLOR_ATTACHMENT9_EXT

_coin.GL_COLOR_ATTACHMENT10_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT10_EXT = _coin.GL_COLOR_ATTACHMENT10_EXT

_coin.GL_COLOR_ATTACHMENT11_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT11_EXT = _coin.GL_COLOR_ATTACHMENT11_EXT

_coin.GL_COLOR_ATTACHMENT12_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT12_EXT = _coin.GL_COLOR_ATTACHMENT12_EXT

_coin.GL_COLOR_ATTACHMENT13_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT13_EXT = _coin.GL_COLOR_ATTACHMENT13_EXT

_coin.GL_COLOR_ATTACHMENT14_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT14_EXT = _coin.GL_COLOR_ATTACHMENT14_EXT

_coin.GL_COLOR_ATTACHMENT15_EXT_swigconstant(_coin)
GL_COLOR_ATTACHMENT15_EXT = _coin.GL_COLOR_ATTACHMENT15_EXT

_coin.GL_DEPTH_ATTACHMENT_EXT_swigconstant(_coin)
GL_DEPTH_ATTACHMENT_EXT = _coin.GL_DEPTH_ATTACHMENT_EXT

_coin.GL_STENCIL_ATTACHMENT_EXT_swigconstant(_coin)
GL_STENCIL_ATTACHMENT_EXT = _coin.GL_STENCIL_ATTACHMENT_EXT

_coin.GL_FRAMEBUFFER_EXT_swigconstant(_coin)
GL_FRAMEBUFFER_EXT = _coin.GL_FRAMEBUFFER_EXT

_coin.GL_RENDERBUFFER_EXT_swigconstant(_coin)
GL_RENDERBUFFER_EXT = _coin.GL_RENDERBUFFER_EXT

_coin.GL_RENDERBUFFER_WIDTH_EXT_swigconstant(_coin)
GL_RENDERBUFFER_WIDTH_EXT = _coin.GL_RENDERBUFFER_WIDTH_EXT

_coin.GL_RENDERBUFFER_HEIGHT_EXT_swigconstant(_coin)
GL_RENDERBUFFER_HEIGHT_EXT = _coin.GL_RENDERBUFFER_HEIGHT_EXT

_coin.GL_RENDERBUFFER_INTERNAL_FORMAT_EXT_swigconstant(_coin)
GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = _coin.GL_RENDERBUFFER_INTERNAL_FORMAT_EXT

_coin.GL_STENCIL_INDEX1_EXT_swigconstant(_coin)
GL_STENCIL_INDEX1_EXT = _coin.GL_STENCIL_INDEX1_EXT

_coin.GL_STENCIL_INDEX4_EXT_swigconstant(_coin)
GL_STENCIL_INDEX4_EXT = _coin.GL_STENCIL_INDEX4_EXT

_coin.GL_STENCIL_INDEX8_EXT_swigconstant(_coin)
GL_STENCIL_INDEX8_EXT = _coin.GL_STENCIL_INDEX8_EXT

_coin.GL_STENCIL_INDEX16_EXT_swigconstant(_coin)
GL_STENCIL_INDEX16_EXT = _coin.GL_STENCIL_INDEX16_EXT

_coin.GL_RENDERBUFFER_RED_SIZE_EXT_swigconstant(_coin)
GL_RENDERBUFFER_RED_SIZE_EXT = _coin.GL_RENDERBUFFER_RED_SIZE_EXT

_coin.GL_RENDERBUFFER_GREEN_SIZE_EXT_swigconstant(_coin)
GL_RENDERBUFFER_GREEN_SIZE_EXT = _coin.GL_RENDERBUFFER_GREEN_SIZE_EXT

_coin.GL_RENDERBUFFER_BLUE_SIZE_EXT_swigconstant(_coin)
GL_RENDERBUFFER_BLUE_SIZE_EXT = _coin.GL_RENDERBUFFER_BLUE_SIZE_EXT

_coin.GL_RENDERBUFFER_ALPHA_SIZE_EXT_swigconstant(_coin)
GL_RENDERBUFFER_ALPHA_SIZE_EXT = _coin.GL_RENDERBUFFER_ALPHA_SIZE_EXT

_coin.GL_RENDERBUFFER_DEPTH_SIZE_EXT_swigconstant(_coin)
GL_RENDERBUFFER_DEPTH_SIZE_EXT = _coin.GL_RENDERBUFFER_DEPTH_SIZE_EXT

_coin.GL_RENDERBUFFER_STENCIL_SIZE_EXT_swigconstant(_coin)
GL_RENDERBUFFER_STENCIL_SIZE_EXT = _coin.GL_RENDERBUFFER_STENCIL_SIZE_EXT

_coin.GL_INVALID_FRAMEBUFFER_OPERATION_swigconstant(_coin)
GL_INVALID_FRAMEBUFFER_OPERATION = _coin.GL_INVALID_FRAMEBUFFER_OPERATION

_coin.GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = _coin.GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING

_coin.GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = _coin.GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE

_coin.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE

_coin.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE

_coin.GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE

_coin.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE

_coin.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE

_coin.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE

_coin.GL_DEPTH_STENCIL_swigconstant(_coin)
GL_DEPTH_STENCIL = _coin.GL_DEPTH_STENCIL

_coin.GL_UNSIGNED_INT_24__swigconstant(_coin)
GL_UNSIGNED_INT_24_ = _coin.GL_UNSIGNED_INT_24_

_coin.GL_DEPTH24_STENCIL8_swigconstant(_coin)
GL_DEPTH24_STENCIL8 = _coin.GL_DEPTH24_STENCIL8

_coin.GL_TEXTURE_STENCIL_SIZE_swigconstant(_coin)
GL_TEXTURE_STENCIL_SIZE = _coin.GL_TEXTURE_STENCIL_SIZE

_coin.GL_SRGB_swigconstant(_coin)
GL_SRGB = _coin.GL_SRGB

_coin.GL_UNSIGNED_NORMALIZED_swigconstant(_coin)
GL_UNSIGNED_NORMALIZED = _coin.GL_UNSIGNED_NORMALIZED

_coin.GL_FRAMEBUFFER_DEFAULT_swigconstant(_coin)
GL_FRAMEBUFFER_DEFAULT = _coin.GL_FRAMEBUFFER_DEFAULT

_coin.GL_FRAMEBUFFER_UNDEFINED_swigconstant(_coin)
GL_FRAMEBUFFER_UNDEFINED = _coin.GL_FRAMEBUFFER_UNDEFINED

_coin.GL_DEPTH_STENCIL_ATTACHMENT_swigconstant(_coin)
GL_DEPTH_STENCIL_ATTACHMENT = _coin.GL_DEPTH_STENCIL_ATTACHMENT

_coin.GL_INDEX_swigconstant(_coin)
GL_INDEX = _coin.GL_INDEX

_coin.GL_MAX_RENDERBUFFER_SIZE_swigconstant(_coin)
GL_MAX_RENDERBUFFER_SIZE = _coin.GL_MAX_RENDERBUFFER_SIZE

_coin.GL_FRAMEBUFFER_BINDING_swigconstant(_coin)
GL_FRAMEBUFFER_BINDING = _coin.GL_FRAMEBUFFER_BINDING

_coin.GL_DRAW_FRAMEBUFFER_BINDING_swigconstant(_coin)
GL_DRAW_FRAMEBUFFER_BINDING = _coin.GL_DRAW_FRAMEBUFFER_BINDING

_coin.GL_RENDERBUFFER_BINDING_swigconstant(_coin)
GL_RENDERBUFFER_BINDING = _coin.GL_RENDERBUFFER_BINDING

_coin.GL_READ_FRAMEBUFFER_swigconstant(_coin)
GL_READ_FRAMEBUFFER = _coin.GL_READ_FRAMEBUFFER

_coin.GL_DRAW_FRAMEBUFFER_swigconstant(_coin)
GL_DRAW_FRAMEBUFFER = _coin.GL_DRAW_FRAMEBUFFER

_coin.GL_READ_FRAMEBUFFER_BINDING_swigconstant(_coin)
GL_READ_FRAMEBUFFER_BINDING = _coin.GL_READ_FRAMEBUFFER_BINDING

_coin.GL_RENDERBUFFER_SAMPLES_swigconstant(_coin)
GL_RENDERBUFFER_SAMPLES = _coin.GL_RENDERBUFFER_SAMPLES

_coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE

_coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME

_coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL

_coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE

_coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER

_coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_swigconstant(_coin)
GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET

_coin.GL_FRAMEBUFFER_COMPLETE_swigconstant(_coin)
GL_FRAMEBUFFER_COMPLETE = _coin.GL_FRAMEBUFFER_COMPLETE

_coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT

_coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT

_coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT

_coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = _coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER

_coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = _coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER

_coin.GL_FRAMEBUFFER_UNSUPPORTED_swigconstant(_coin)
GL_FRAMEBUFFER_UNSUPPORTED = _coin.GL_FRAMEBUFFER_UNSUPPORTED

_coin.GL_MAX_COLOR_ATTACHMENTS_swigconstant(_coin)
GL_MAX_COLOR_ATTACHMENTS = _coin.GL_MAX_COLOR_ATTACHMENTS

_coin.GL_COLOR_ATTACHMENT0_swigconstant(_coin)
GL_COLOR_ATTACHMENT0 = _coin.GL_COLOR_ATTACHMENT0

_coin.GL_COLOR_ATTACHMENT1_swigconstant(_coin)
GL_COLOR_ATTACHMENT1 = _coin.GL_COLOR_ATTACHMENT1

_coin.GL_COLOR_ATTACHMENT2_swigconstant(_coin)
GL_COLOR_ATTACHMENT2 = _coin.GL_COLOR_ATTACHMENT2

_coin.GL_COLOR_ATTACHMENT3_swigconstant(_coin)
GL_COLOR_ATTACHMENT3 = _coin.GL_COLOR_ATTACHMENT3

_coin.GL_COLOR_ATTACHMENT4_swigconstant(_coin)
GL_COLOR_ATTACHMENT4 = _coin.GL_COLOR_ATTACHMENT4

_coin.GL_COLOR_ATTACHMENT5_swigconstant(_coin)
GL_COLOR_ATTACHMENT5 = _coin.GL_COLOR_ATTACHMENT5

_coin.GL_COLOR_ATTACHMENT6_swigconstant(_coin)
GL_COLOR_ATTACHMENT6 = _coin.GL_COLOR_ATTACHMENT6

_coin.GL_COLOR_ATTACHMENT7_swigconstant(_coin)
GL_COLOR_ATTACHMENT7 = _coin.GL_COLOR_ATTACHMENT7

_coin.GL_COLOR_ATTACHMENT8_swigconstant(_coin)
GL_COLOR_ATTACHMENT8 = _coin.GL_COLOR_ATTACHMENT8

_coin.GL_COLOR_ATTACHMENT9_swigconstant(_coin)
GL_COLOR_ATTACHMENT9 = _coin.GL_COLOR_ATTACHMENT9

_coin.GL_COLOR_ATTACHMENT10_swigconstant(_coin)
GL_COLOR_ATTACHMENT10 = _coin.GL_COLOR_ATTACHMENT10

_coin.GL_COLOR_ATTACHMENT11_swigconstant(_coin)
GL_COLOR_ATTACHMENT11 = _coin.GL_COLOR_ATTACHMENT11

_coin.GL_COLOR_ATTACHMENT12_swigconstant(_coin)
GL_COLOR_ATTACHMENT12 = _coin.GL_COLOR_ATTACHMENT12

_coin.GL_COLOR_ATTACHMENT13_swigconstant(_coin)
GL_COLOR_ATTACHMENT13 = _coin.GL_COLOR_ATTACHMENT13

_coin.GL_COLOR_ATTACHMENT14_swigconstant(_coin)
GL_COLOR_ATTACHMENT14 = _coin.GL_COLOR_ATTACHMENT14

_coin.GL_COLOR_ATTACHMENT15_swigconstant(_coin)
GL_COLOR_ATTACHMENT15 = _coin.GL_COLOR_ATTACHMENT15

_coin.GL_DEPTH_ATTACHMENT_swigconstant(_coin)
GL_DEPTH_ATTACHMENT = _coin.GL_DEPTH_ATTACHMENT

_coin.GL_STENCIL_ATTACHMENT_swigconstant(_coin)
GL_STENCIL_ATTACHMENT = _coin.GL_STENCIL_ATTACHMENT

_coin.GL_FRAMEBUFFER_swigconstant(_coin)
GL_FRAMEBUFFER = _coin.GL_FRAMEBUFFER

_coin.GL_RENDERBUFFER_swigconstant(_coin)
GL_RENDERBUFFER = _coin.GL_RENDERBUFFER

_coin.GL_RENDERBUFFER_WIDTH_swigconstant(_coin)
GL_RENDERBUFFER_WIDTH = _coin.GL_RENDERBUFFER_WIDTH

_coin.GL_RENDERBUFFER_HEIGHT_swigconstant(_coin)
GL_RENDERBUFFER_HEIGHT = _coin.GL_RENDERBUFFER_HEIGHT

_coin.GL_RENDERBUFFER_INTERNAL_FORMAT_swigconstant(_coin)
GL_RENDERBUFFER_INTERNAL_FORMAT = _coin.GL_RENDERBUFFER_INTERNAL_FORMAT

_coin.GL_STENCIL_INDEX1_swigconstant(_coin)
GL_STENCIL_INDEX1 = _coin.GL_STENCIL_INDEX1

_coin.GL_STENCIL_INDEX4_swigconstant(_coin)
GL_STENCIL_INDEX4 = _coin.GL_STENCIL_INDEX4

_coin.GL_STENCIL_INDEX8_swigconstant(_coin)
GL_STENCIL_INDEX8 = _coin.GL_STENCIL_INDEX8

_coin.GL_STENCIL_INDEX16_swigconstant(_coin)
GL_STENCIL_INDEX16 = _coin.GL_STENCIL_INDEX16

_coin.GL_RENDERBUFFER_RED_SIZE_swigconstant(_coin)
GL_RENDERBUFFER_RED_SIZE = _coin.GL_RENDERBUFFER_RED_SIZE

_coin.GL_RENDERBUFFER_GREEN_SIZE_swigconstant(_coin)
GL_RENDERBUFFER_GREEN_SIZE = _coin.GL_RENDERBUFFER_GREEN_SIZE

_coin.GL_RENDERBUFFER_BLUE_SIZE_swigconstant(_coin)
GL_RENDERBUFFER_BLUE_SIZE = _coin.GL_RENDERBUFFER_BLUE_SIZE

_coin.GL_RENDERBUFFER_ALPHA_SIZE_swigconstant(_coin)
GL_RENDERBUFFER_ALPHA_SIZE = _coin.GL_RENDERBUFFER_ALPHA_SIZE

_coin.GL_RENDERBUFFER_DEPTH_SIZE_swigconstant(_coin)
GL_RENDERBUFFER_DEPTH_SIZE = _coin.GL_RENDERBUFFER_DEPTH_SIZE

_coin.GL_RENDERBUFFER_STENCIL_SIZE_swigconstant(_coin)
GL_RENDERBUFFER_STENCIL_SIZE = _coin.GL_RENDERBUFFER_STENCIL_SIZE

_coin.GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_swigconstant(_coin)
GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = _coin.GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE

_coin.GL_MAX_SAMPLES_swigconstant(_coin)
GL_MAX_SAMPLES = _coin.GL_MAX_SAMPLES

_coin.GLX_PBUFFER_WIDTH_swigconstant(_coin)
GLX_PBUFFER_WIDTH = _coin.GLX_PBUFFER_WIDTH

_coin.GLX_PBUFFER_HEIGHT_swigconstant(_coin)
GLX_PBUFFER_HEIGHT = _coin.GLX_PBUFFER_HEIGHT

_coin.GLX_DRAWABLE_TYPE_swigconstant(_coin)
GLX_DRAWABLE_TYPE = _coin.GLX_DRAWABLE_TYPE

_coin.GLX_RENDER_TYPE_swigconstant(_coin)
GLX_RENDER_TYPE = _coin.GLX_RENDER_TYPE

_coin.GLX_RGBA_TYPE_swigconstant(_coin)
GLX_RGBA_TYPE = _coin.GLX_RGBA_TYPE

_coin.GLX_RGBA_BIT_swigconstant(_coin)
GLX_RGBA_BIT = _coin.GLX_RGBA_BIT

_coin.GLX_PBUFFER_BIT_swigconstant(_coin)
GLX_PBUFFER_BIT = _coin.GLX_PBUFFER_BIT

_coin.GLX_MAX_PBUFFER_WIDTH_swigconstant(_coin)
GLX_MAX_PBUFFER_WIDTH = _coin.GLX_MAX_PBUFFER_WIDTH

_coin.GLX_MAX_PBUFFER_HEIGHT_swigconstant(_coin)
GLX_MAX_PBUFFER_HEIGHT = _coin.GLX_MAX_PBUFFER_HEIGHT

_coin.GLX_MAX_PBUFFER_PIXELS_swigconstant(_coin)
GLX_MAX_PBUFFER_PIXELS = _coin.GLX_MAX_PBUFFER_PIXELS

_coin.GLU_VERSION_swigconstant(_coin)
GLU_VERSION = _coin.GLU_VERSION

_coin.GLU_EXTENSIONS_swigconstant(_coin)
GLU_EXTENSIONS = _coin.GLU_EXTENSIONS

_coin.GLU_OUTLINE_POLYGON_swigconstant(_coin)
GLU_OUTLINE_POLYGON = _coin.GLU_OUTLINE_POLYGON

_coin.GLU_OUTLINE_PATCH_swigconstant(_coin)
GLU_OUTLINE_PATCH = _coin.GLU_OUTLINE_PATCH

_coin.GLU_NURBS_ERROR_swigconstant(_coin)
GLU_NURBS_ERROR = _coin.GLU_NURBS_ERROR

_coin.GLU_ERROR_swigconstant(_coin)
GLU_ERROR = _coin.GLU_ERROR

_coin.GLU_NURBS_BEGIN_swigconstant(_coin)
GLU_NURBS_BEGIN = _coin.GLU_NURBS_BEGIN

_coin.GLU_NURBS_VERTEX_swigconstant(_coin)
GLU_NURBS_VERTEX = _coin.GLU_NURBS_VERTEX

_coin.GLU_NURBS_NORMAL_swigconstant(_coin)
GLU_NURBS_NORMAL = _coin.GLU_NURBS_NORMAL

_coin.GLU_NURBS_COLOR_swigconstant(_coin)
GLU_NURBS_COLOR = _coin.GLU_NURBS_COLOR

_coin.GLU_NURBS_TEXTURE_COORD_swigconstant(_coin)
GLU_NURBS_TEXTURE_COORD = _coin.GLU_NURBS_TEXTURE_COORD

_coin.GLU_NURBS_END_swigconstant(_coin)
GLU_NURBS_END = _coin.GLU_NURBS_END

_coin.GLU_NURBS_BEGIN_DATA_swigconstant(_coin)
GLU_NURBS_BEGIN_DATA = _coin.GLU_NURBS_BEGIN_DATA

_coin.GLU_NURBS_VERTEX_DATA_swigconstant(_coin)
GLU_NURBS_VERTEX_DATA = _coin.GLU_NURBS_VERTEX_DATA

_coin.GLU_NURBS_NORMAL_DATA_swigconstant(_coin)
GLU_NURBS_NORMAL_DATA = _coin.GLU_NURBS_NORMAL_DATA

_coin.GLU_NURBS_COLOR_DATA_swigconstant(_coin)
GLU_NURBS_COLOR_DATA = _coin.GLU_NURBS_COLOR_DATA

_coin.GLU_NURBS_TEXTURE_COORD_DATA_swigconstant(_coin)
GLU_NURBS_TEXTURE_COORD_DATA = _coin.GLU_NURBS_TEXTURE_COORD_DATA

_coin.GLU_NURBS_END_DATA_swigconstant(_coin)
GLU_NURBS_END_DATA = _coin.GLU_NURBS_END_DATA

_coin.GLU_AUTO_LOAD_MATRIX_swigconstant(_coin)
GLU_AUTO_LOAD_MATRIX = _coin.GLU_AUTO_LOAD_MATRIX

_coin.GLU_CULLING_swigconstant(_coin)
GLU_CULLING = _coin.GLU_CULLING

_coin.GLU_SAMPLING_TOLERANCE_swigconstant(_coin)
GLU_SAMPLING_TOLERANCE = _coin.GLU_SAMPLING_TOLERANCE

_coin.GLU_DISPLAY_MODE_swigconstant(_coin)
GLU_DISPLAY_MODE = _coin.GLU_DISPLAY_MODE

_coin.GLU_PARAMETRIC_TOLERANCE_swigconstant(_coin)
GLU_PARAMETRIC_TOLERANCE = _coin.GLU_PARAMETRIC_TOLERANCE

_coin.GLU_SAMPLING_METHOD_swigconstant(_coin)
GLU_SAMPLING_METHOD = _coin.GLU_SAMPLING_METHOD

_coin.GLU_U_STEP_swigconstant(_coin)
GLU_U_STEP = _coin.GLU_U_STEP

_coin.GLU_V_STEP_swigconstant(_coin)
GLU_V_STEP = _coin.GLU_V_STEP

_coin.GLU_NURBS_MODE_swigconstant(_coin)
GLU_NURBS_MODE = _coin.GLU_NURBS_MODE

_coin.GLU_NURBS_TESSELLATOR_swigconstant(_coin)
GLU_NURBS_TESSELLATOR = _coin.GLU_NURBS_TESSELLATOR

_coin.GLU_NURBS_RENDERER_swigconstant(_coin)
GLU_NURBS_RENDERER = _coin.GLU_NURBS_RENDERER

_coin.GLU_OBJECT_PARAMETRIC_ERROR_swigconstant(_coin)
GLU_OBJECT_PARAMETRIC_ERROR = _coin.GLU_OBJECT_PARAMETRIC_ERROR

_coin.GLU_OBJECT_PATH_LENGTH_swigconstant(_coin)
GLU_OBJECT_PATH_LENGTH = _coin.GLU_OBJECT_PATH_LENGTH

_coin.GLU_PATH_LENGTH_swigconstant(_coin)
GLU_PATH_LENGTH = _coin.GLU_PATH_LENGTH

_coin.GLU_PARAMETRIC_ERROR_swigconstant(_coin)
GLU_PARAMETRIC_ERROR = _coin.GLU_PARAMETRIC_ERROR

_coin.GLU_DOMAIN_DISTANCE_swigconstant(_coin)
GLU_DOMAIN_DISTANCE = _coin.GLU_DOMAIN_DISTANCE

_coin.GLU_MAP1_TRIM_2_swigconstant(_coin)
GLU_MAP1_TRIM_2 = _coin.GLU_MAP1_TRIM_2

_coin.GLU_MAP1_TRIM_3_swigconstant(_coin)
GLU_MAP1_TRIM_3 = _coin.GLU_MAP1_TRIM_3

_coin.GLU_POINT_swigconstant(_coin)
GLU_POINT = _coin.GLU_POINT

_coin.GLU_LINE_swigconstant(_coin)
GLU_LINE = _coin.GLU_LINE

_coin.GLU_FILL_swigconstant(_coin)
GLU_FILL = _coin.GLU_FILL

_coin.GLU_SILHOUETTE_swigconstant(_coin)
GLU_SILHOUETTE = _coin.GLU_SILHOUETTE

_coin.GLU_TESS_BEGIN_swigconstant(_coin)
GLU_TESS_BEGIN = _coin.GLU_TESS_BEGIN

_coin.GLU_TESS_VERTEX_swigconstant(_coin)
GLU_TESS_VERTEX = _coin.GLU_TESS_VERTEX

_coin.GLU_TESS_END_swigconstant(_coin)
GLU_TESS_END = _coin.GLU_TESS_END

_coin.GLU_TESS_ERROR_swigconstant(_coin)
GLU_TESS_ERROR = _coin.GLU_TESS_ERROR

_coin.GLU_TESS_COMBINE_swigconstant(_coin)
GLU_TESS_COMBINE = _coin.GLU_TESS_COMBINE

_coin.GLU_TESS_BEGIN_DATA_swigconstant(_coin)
GLU_TESS_BEGIN_DATA = _coin.GLU_TESS_BEGIN_DATA

_coin.GLU_TESS_VERTEX_DATA_swigconstant(_coin)
GLU_TESS_VERTEX_DATA = _coin.GLU_TESS_VERTEX_DATA

_coin.GLU_TESS_END_DATA_swigconstant(_coin)
GLU_TESS_END_DATA = _coin.GLU_TESS_END_DATA

_coin.GLU_TESS_ERROR_DATA_swigconstant(_coin)
GLU_TESS_ERROR_DATA = _coin.GLU_TESS_ERROR_DATA

_coin.GLU_TESS_MISSING_BEGIN_POLYGON_swigconstant(_coin)
GLU_TESS_MISSING_BEGIN_POLYGON = _coin.GLU_TESS_MISSING_BEGIN_POLYGON

_coin.GLU_TESS_MISSING_BEGIN_CONTOUR_swigconstant(_coin)
GLU_TESS_MISSING_BEGIN_CONTOUR = _coin.GLU_TESS_MISSING_BEGIN_CONTOUR

_coin.GLU_TESS_MISSING_END_POLYGON_swigconstant(_coin)
GLU_TESS_MISSING_END_POLYGON = _coin.GLU_TESS_MISSING_END_POLYGON

_coin.GLU_TESS_MISSING_END_CONTOUR_swigconstant(_coin)
GLU_TESS_MISSING_END_CONTOUR = _coin.GLU_TESS_MISSING_END_CONTOUR

_coin.GLU_TESS_NEED_COMBINE_CALLBACK_swigconstant(_coin)
GLU_TESS_NEED_COMBINE_CALLBACK = _coin.GLU_TESS_NEED_COMBINE_CALLBACK

_coin.WGL_COLOR_BITS_ARB_swigconstant(_coin)
WGL_COLOR_BITS_ARB = _coin.WGL_COLOR_BITS_ARB

_coin.WGL_ALPHA_BITS_ARB_swigconstant(_coin)
WGL_ALPHA_BITS_ARB = _coin.WGL_ALPHA_BITS_ARB

_coin.WGL_DEPTH_BITS_ARB_swigconstant(_coin)
WGL_DEPTH_BITS_ARB = _coin.WGL_DEPTH_BITS_ARB

_coin.WGL_STENCIL_BITS_ARB_swigconstant(_coin)
WGL_STENCIL_BITS_ARB = _coin.WGL_STENCIL_BITS_ARB

_coin.WGL_DRAW_TO_PBUFFER_ARB_swigconstant(_coin)
WGL_DRAW_TO_PBUFFER_ARB = _coin.WGL_DRAW_TO_PBUFFER_ARB

_coin.WGL_PBUFFER_WIDTH_ARB_swigconstant(_coin)
WGL_PBUFFER_WIDTH_ARB = _coin.WGL_PBUFFER_WIDTH_ARB

_coin.WGL_PBUFFER_HEIGHT_ARB_swigconstant(_coin)
WGL_PBUFFER_HEIGHT_ARB = _coin.WGL_PBUFFER_HEIGHT_ARB

_coin.WGL_BIND_TO_TEXTURE_RGB_ARB_swigconstant(_coin)
WGL_BIND_TO_TEXTURE_RGB_ARB = _coin.WGL_BIND_TO_TEXTURE_RGB_ARB

_coin.WGL_BIND_TO_TEXTURE_RGBA_ARB_swigconstant(_coin)
WGL_BIND_TO_TEXTURE_RGBA_ARB = _coin.WGL_BIND_TO_TEXTURE_RGBA_ARB

_coin.WGL_TEXTURE_FORMAT_ARB_swigconstant(_coin)
WGL_TEXTURE_FORMAT_ARB = _coin.WGL_TEXTURE_FORMAT_ARB

_coin.WGL_TEXTURE_TARGET_ARB_swigconstant(_coin)
WGL_TEXTURE_TARGET_ARB = _coin.WGL_TEXTURE_TARGET_ARB

_coin.WGL_MIPMAP_TEXTURE_ARB_swigconstant(_coin)
WGL_MIPMAP_TEXTURE_ARB = _coin.WGL_MIPMAP_TEXTURE_ARB

_coin.WGL_TEXTURE_RGB_ARB_swigconstant(_coin)
WGL_TEXTURE_RGB_ARB = _coin.WGL_TEXTURE_RGB_ARB

_coin.WGL_TEXTURE_RGBA_ARB_swigconstant(_coin)
WGL_TEXTURE_RGBA_ARB = _coin.WGL_TEXTURE_RGBA_ARB

_coin.WGL_NO_TEXTURE_ARB_swigconstant(_coin)
WGL_NO_TEXTURE_ARB = _coin.WGL_NO_TEXTURE_ARB

_coin.WGL_TEXTURE_CUBE_MAP_ARB_swigconstant(_coin)
WGL_TEXTURE_CUBE_MAP_ARB = _coin.WGL_TEXTURE_CUBE_MAP_ARB

_coin.WGL_TEXTURE_1D_ARB_swigconstant(_coin)
WGL_TEXTURE_1D_ARB = _coin.WGL_TEXTURE_1D_ARB

_coin.WGL_TEXTURE_2D_ARB_swigconstant(_coin)
WGL_TEXTURE_2D_ARB = _coin.WGL_TEXTURE_2D_ARB

_coin.WGL_MIPMAP_LEVEL_ARB_swigconstant(_coin)
WGL_MIPMAP_LEVEL_ARB = _coin.WGL_MIPMAP_LEVEL_ARB

_coin.WGL_FRONT_LEFT_ARB_swigconstant(_coin)
WGL_FRONT_LEFT_ARB = _coin.WGL_FRONT_LEFT_ARB

_coin.WGL_FRONT_RIGHT_ARB_swigconstant(_coin)
WGL_FRONT_RIGHT_ARB = _coin.WGL_FRONT_RIGHT_ARB

_coin.WGL_BACK_LEFT_ARB_swigconstant(_coin)
WGL_BACK_LEFT_ARB = _coin.WGL_BACK_LEFT_ARB

_coin.WGL_BACK_RIGHT_ARB_swigconstant(_coin)
WGL_BACK_RIGHT_ARB = _coin.WGL_BACK_RIGHT_ARB

_coin.WGL_MAX_PBUFFER_PIXELS_ARB_swigconstant(_coin)
WGL_MAX_PBUFFER_PIXELS_ARB = _coin.WGL_MAX_PBUFFER_PIXELS_ARB

_coin.WGL_MAX_PBUFFER_WIDTH_ARB_swigconstant(_coin)
WGL_MAX_PBUFFER_WIDTH_ARB = _coin.WGL_MAX_PBUFFER_WIDTH_ARB

_coin.WGL_MAX_PBUFFER_HEIGHT_ARB_swigconstant(_coin)
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, count):
        """__init__(SbBarrier self, unsigned int count) -> SbBarrier"""
        this = _coin.new_SbBarrier(count)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SbBarrier
    __del__ = lambda self: None

    def enter(self):
        """enter(SbBarrier 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__(SbMutex 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(SbMutex self) -> int"""
        return _coin.SbMutex_lock(self)


    def tryLock(self):
        """tryLock(SbMutex self) -> SbBool"""
        return _coin.SbMutex_tryLock(self)


    def unlock(self):
        """unlock(SbMutex 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__(SbThreadMutex 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(SbThreadMutex self) -> int"""
        return _coin.SbThreadMutex_lock(self)


    def tryLock(self):
        """tryLock(SbThreadMutex self) -> SbBool"""
        return _coin.SbThreadMutex_tryLock(self)


    def unlock(self):
        """unlock(SbThreadMutex 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__(SbThreadAutoLock self, SbMutex mutexptr) -> SbThreadAutoLock
        __init__(SbThreadAutoLock 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__(SbCondVar 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, mutex):
        """wait(SbCondVar self, SbMutex mutex) -> SbBool"""
        return _coin.SbCondVar_wait(self, mutex)


    def timedWait(self, mutex, period):
        """timedWait(SbCondVar self, SbMutex mutex, SbTime period) -> SbBool"""
        return _coin.SbCondVar_timedWait(self, mutex, period)


    def wakeOne(self):
        """wakeOne(SbCondVar self)"""
        return _coin.SbCondVar_wakeOne(self)


    def wakeAll(self):
        """wakeAll(SbCondVar 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__(SbFifo 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, ptr, type):
        """assign(SbFifo self, void * ptr, uint32_t type)"""
        return _coin.SbFifo_assign(self, ptr, type)


    def retrieve(self, ptr, type):
        """retrieve(SbFifo self, void *& ptr, uint32_t & type)"""
        return _coin.SbFifo_retrieve(self, ptr, type)


    def tryRetrieve(self, ptr, type):
        """tryRetrieve(SbFifo self, void *& ptr, uint32_t & type) -> SbBool"""
        return _coin.SbFifo_tryRetrieve(self, ptr, type)


    def size(self):
        """size(SbFifo self) -> unsigned int"""
        return _coin.SbFifo_size(self)


    def lock(self):
        """lock(SbFifo self)"""
        return _coin.SbFifo_lock(self)


    def unlock(self):
        """unlock(SbFifo self)"""
        return _coin.SbFifo_unlock(self)


    def peek(self, item, type):
        """peek(SbFifo self, void *& item, uint32_t & type) -> SbBool"""
        return _coin.SbFifo_peek(self, item, type)


    def contains(self, item):
        """contains(SbFifo self, void * item) -> SbBool"""
        return _coin.SbFifo_contains(self, item)


    def reclaim(self, item):
        """reclaim(SbFifo self, void * item) -> SbBool"""
        return _coin.SbFifo_reclaim(self, item)

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, policy):
        """__init__(SbRWMutex self, SbRWMutex::Precedence policy) -> SbRWMutex"""
        this = _coin.new_SbRWMutex(policy)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _coin.delete_SbRWMutex
    __del__ = lambda self: None

    def writeLock(self):
        """writeLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_writeLock(self)


    def tryWriteLock(self):
        """tryWriteLock(SbRWMutex self) -> SbBool"""
        return _coin.SbRWMutex_tryWriteLock(self)


    def writeUnlock(self):
        """writeUnlock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_writeUnlock(self)


    def readLock(self):
        """readLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_readLock(self)


    def tryReadLock(self):
        """tryReadLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_tryReadLock(self)


    def readUnlock(self):
        """readUnlock(SbRWMutex 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__(SbStorage self, unsigned int size) -> SbStorage
        __init__(SbStorage 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(SbStorage self) -> void *"""
        return _coin.SbStorage_get(self)


    def applyToAll(self, func, closure):
        """applyToAll(SbStorage self, SbStorageApplyFunc * func, void * closure)"""
        return _coin.SbStorage_applyToAll(self, func, closure)

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(func, closure):
        """create(void *(*)(void *) func, void * closure) -> SbThread"""
        return _coin.SbThread_create(func, closure)

    create = staticmethod(create)

    def destroy(thread):
        """destroy(SbThread thread)"""
        return _coin.SbThread_destroy(thread)

    destroy = staticmethod(destroy)

    def join(*args):
        """
        join(void ** retval=0) -> SbBool
        join() -> SbBool
        join(SbThread thread, void ** retval=0) -> SbBool
        join(SbThread thread) -> SbBool
        """
        return _coin.SbThread_join(*args)

    join = staticmethod(join)
SbThread_swigregister = _coin.SbThread_swigregister
SbThread_swigregister(SbThread)

def SbThread_create(func, closure):
    """SbThread_create(void *(*)(void *) func, void * closure) -> SbThread"""
    return _coin.SbThread_create(func, closure)

def SbThread_destroy(thread):
    """SbThread_destroy(SbThread thread)"""
    return _coin.SbThread_destroy(thread)

def SbThread_join(*args):
    """
    join(void ** retval=0) -> SbBool
    join() -> SbBool
    join(SbThread thread, void ** retval=0) -> 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(SoVRMLParent 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(SoVRMLParent self) -> SbBool"""
        return _coin.SoVRMLParent_affectsState(self)


    def addChild(self, child):
        """addChild(SoVRMLParent self, SoNode child)"""
        return _coin.SoVRMLParent_addChild(self, child)


    def insertChild(self, child, idx):
        """insertChild(SoVRMLParent self, SoNode child, int idx)"""
        return _coin.SoVRMLParent_insertChild(self, child, idx)


    def getChild(self, idx):
        """getChild(SoVRMLParent self, int idx) -> SoNode"""
        return _coin.SoVRMLParent_getChild(self, idx)


    def findChild(self, child):
        """findChild(SoVRMLParent self, SoNode child) -> int"""
        return _coin.SoVRMLParent_findChild(self, child)


    def getNumChildren(self):
        """getNumChildren(SoVRMLParent self) -> int"""
        return _coin.SoVRMLParent_getNumChildren(self)


    def removeChild(self, *args):
        """
        removeChild(SoVRMLParent self, int idx)
        removeChild(SoVRMLParent self, SoNode child)
        """
        return _coin.SoVRMLParent_removeChild(self, *args)


    def removeAllChildren(self):
        """removeAllChildren(SoVRMLParent self)"""
        return _coin.SoVRMLParent_removeAllChildren(self)


    def replaceChild(self, *args):
        """
        replaceChild(SoVRMLParent self, int idx, SoNode child)
        replaceChild(SoVRMLParent self, SoNode old, SoNode child)
        """
        return _coin.SoVRMLParent_replaceChild(self, *args)


    def getChildren(self):
        """getChildren(SoVRMLParent self) -> SoChildList"""
        return _coin.SoVRMLParent_getChildren(self)


    def doAction(self, action):
        """doAction(SoVRMLParent self, SoAction action)"""
        return _coin.SoVRMLParent_doAction(self, action)


    def search(self, action):
        """search(SoVRMLParent self, SoSearchAction action)"""
        return _coin.SoVRMLParent_search(self, action)


    def write(self, action):
        """write(SoVRMLParent self, SoWriteAction action)"""
        return _coin.SoVRMLParent_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLParent self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLParent_getPrimitiveCount(self, action)


    def updateChildList(*args):
        """
        updateChildList(SoNode const *const * nodes, int const 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 const *const * nodes, int const 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(SoVRMLAnchor self) -> SoType"""
        return _coin.SoVRMLAnchor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLAnchor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLAnchor 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(arg1, closure):
        """setFetchURLCallBack(SoVRMLAnchorCB * arg1, void * closure)"""
        return _coin.SoVRMLAnchor_setFetchURLCallBack(arg1, closure)

    setFetchURLCallBack = staticmethod(setFetchURLCallBack)

    def handleEvent(self, action):
        """handleEvent(SoVRMLAnchor self, SoHandleEventAction action)"""
        return _coin.SoVRMLAnchor_handleEvent(self, action)

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(arg2, closure):
    """SoVRMLAnchor_setFetchURLCallBack(SoVRMLAnchorCB * arg2, void * closure)"""
    return _coin.SoVRMLAnchor_setFetchURLCallBack(arg2, closure)

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(SoVRMLAppearance self) -> SoType"""
        return _coin.SoVRMLAppearance_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLAppearance_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLAppearance 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, action):
        """doAction(SoVRMLAppearance self, SoAction action)"""
        return _coin.SoVRMLAppearance_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLAppearance self, SoCallbackAction action)"""
        return _coin.SoVRMLAppearance_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLAppearance self, SoGLRenderAction action)"""
        return _coin.SoVRMLAppearance_GLRender(self, action)


    def search(self, action):
        """search(SoVRMLAppearance self, SoSearchAction action)"""
        return _coin.SoVRMLAppearance_search(self, action)


    def getChildren(self):
        """getChildren(SoVRMLAppearance self) -> SoChildList"""
        return _coin.SoVRMLAppearance_getChildren(self)


    def notify(self, list):
        """notify(SoVRMLAppearance self, SoNotList list)"""
        return _coin.SoVRMLAppearance_notify(self, list)


    def copyContents(self, arg2, copyConn):
        """copyContents(SoVRMLAppearance self, SoFieldContainer arg2, SbBool copyConn)"""
        return _coin.SoVRMLAppearance_copyContents(self, arg2, copyConn)

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(SoVRMLAudioClip self) -> SoType"""
        return _coin.SoVRMLAudioClip_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLAudioClip_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLAudioClip 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(subdirectories):
        """setSubdirectories(SbList< SbString > const & subdirectories)"""
        return _coin.SoVRMLAudioClip_setSubdirectories(subdirectories)

    setSubdirectories = staticmethod(setSubdirectories)

    def getSubdirectories():
        """getSubdirectories() -> SbStringList"""
        return _coin.SoVRMLAudioClip_getSubdirectories()

    getSubdirectories = staticmethod(getSubdirectories)

    def setDefaultPauseBetweenTracks(pause):
        """setDefaultPauseBetweenTracks(SbTime pause)"""
        return _coin.SoVRMLAudioClip_setDefaultPauseBetweenTracks(pause)

    setDefaultPauseBetweenTracks = staticmethod(setDefaultPauseBetweenTracks)

    def getDefaultPauseBetweenTracks():
        """getDefaultPauseBetweenTracks() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultPauseBetweenTracks()

    getDefaultPauseBetweenTracks = staticmethod(getDefaultPauseBetweenTracks)

    def setDefaultIntroPause(pause):
        """setDefaultIntroPause(SbTime pause)"""
        return _coin.SoVRMLAudioClip_setDefaultIntroPause(pause)

    setDefaultIntroPause = staticmethod(setDefaultIntroPause)

    def getDefaultIntroPause():
        """getDefaultIntroPause() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultIntroPause()

    getDefaultIntroPause = staticmethod(getDefaultIntroPause)

    def setDefaultSampleRate(samplerate):
        """setDefaultSampleRate(int samplerate)"""
        return _coin.SoVRMLAudioClip_setDefaultSampleRate(samplerate)

    setDefaultSampleRate = staticmethod(setDefaultSampleRate)

    def getDefaultSampleRate():
        """getDefaultSampleRate() -> int"""
        return _coin.SoVRMLAudioClip_getDefaultSampleRate()

    getDefaultSampleRate = staticmethod(getDefaultSampleRate)

    def setDefaultTimerInterval(interval):
        """setDefaultTimerInterval(SbTime interval)"""
        return _coin.SoVRMLAudioClip_setDefaultTimerInterval(interval)

    setDefaultTimerInterval = staticmethod(setDefaultTimerInterval)

    def getDefaultTimerInterval():
        """getDefaultTimerInterval() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultTimerInterval()

    getDefaultTimerInterval = staticmethod(getDefaultTimerInterval)

    def getSampleRate(self):
        """getSampleRate(SoVRMLAudioClip self) -> int"""
        return _coin.SoVRMLAudioClip_getSampleRate(self)


    def open(self, url):
        """open(SoVRMLAudioClip self, SbStringList url) -> void *"""
        return _coin.SoVRMLAudioClip_open(self, url)


    def read(self, datasource, buffer, numframes, channels):
        """read(SoVRMLAudioClip self, void * datasource, void * buffer, int numframes, int & channels) -> size_t"""
        return _coin.SoVRMLAudioClip_read(self, datasource, buffer, numframes, channels)


    def seek(self, datasource, offset, whence):
        """seek(SoVRMLAudioClip self, void * datasource, long offset, int whence) -> int"""
        return _coin.SoVRMLAudioClip_seek(self, datasource, offset, whence)


    def tell(self, datasource):
        """tell(SoVRMLAudioClip self, void * datasource) -> long"""
        return _coin.SoVRMLAudioClip_tell(self, datasource)


    def close(self, datasource):
        """close(SoVRMLAudioClip self, void * datasource) -> int"""
        return _coin.SoVRMLAudioClip_close(self, datasource)


    def setCallbacks(self, opencb, readcb, seekcb, tellcb, closecb, userdataptr):
        """setCallbacks(SoVRMLAudioClip self, SoVRMLAudioClip::open_func * opencb, SoVRMLAudioClip::read_func * readcb, SoVRMLAudioClip::seek_func * seekcb, SoVRMLAudioClip::tell_func * tellcb, SoVRMLAudioClip::close_func * closecb, void * userdataptr)"""
        return _coin.SoVRMLAudioClip_setCallbacks(self, opencb, readcb, seekcb, tellcb, closecb, userdataptr)

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(subdirectories):
    """SoVRMLAudioClip_setSubdirectories(SbList< SbString > const & subdirectories)"""
    return _coin.SoVRMLAudioClip_setSubdirectories(subdirectories)

def SoVRMLAudioClip_getSubdirectories():
    """SoVRMLAudioClip_getSubdirectories() -> SbStringList"""
    return _coin.SoVRMLAudioClip_getSubdirectories()

def SoVRMLAudioClip_setDefaultPauseBetweenTracks(pause):
    """SoVRMLAudioClip_setDefaultPauseBetweenTracks(SbTime pause)"""
    return _coin.SoVRMLAudioClip_setDefaultPauseBetweenTracks(pause)

def SoVRMLAudioClip_getDefaultPauseBetweenTracks():
    """SoVRMLAudioClip_getDefaultPauseBetweenTracks() -> SbTime"""
    return _coin.SoVRMLAudioClip_getDefaultPauseBetweenTracks()

def SoVRMLAudioClip_setDefaultIntroPause(pause):
    """SoVRMLAudioClip_setDefaultIntroPause(SbTime pause)"""
    return _coin.SoVRMLAudioClip_setDefaultIntroPause(pause)

def SoVRMLAudioClip_getDefaultIntroPause():
    """SoVRMLAudioClip_getDefaultIntroPause() -> SbTime"""
    return _coin.SoVRMLAudioClip_getDefaultIntroPause()

def SoVRMLAudioClip_setDefaultSampleRate(samplerate):
    """SoVRMLAudioClip_setDefaultSampleRate(int samplerate)"""
    return _coin.SoVRMLAudioClip_setDefaultSampleRate(samplerate)

def SoVRMLAudioClip_getDefaultSampleRate():
    """SoVRMLAudioClip_getDefaultSampleRate() -> int"""
    return _coin.SoVRMLAudioClip_getDefaultSampleRate()

def SoVRMLAudioClip_setDefaultTimerInterval(interval):
    """SoVRMLAudioClip_setDefaultTimerInterval(SbTime interval)"""
    return _coin.SoVRMLAudioClip_setDefaultTimerInterval(interval)

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(SoVRMLBackground self) -> SoType"""
        return _coin.SoVRMLBackground_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLBackground_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLBackground 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, action):
        """GLRender(SoVRMLBackground self, SoGLRenderAction action)"""
        return _coin.SoVRMLBackground_GLRender(self, action)

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(SoVRMLBillboard self) -> SoType"""
        return _coin.SoVRMLBillboard_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLBillboard_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoVRMLBillboard self) -> SoVRMLBillboard
        __init__(SoVRMLBillboard 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, action):
        """doAction(SoVRMLBillboard self, SoAction action)"""
        return _coin.SoVRMLBillboard_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLBillboard self, SoCallbackAction action)"""
        return _coin.SoVRMLBillboard_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLBillboard self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLBillboard_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoVRMLBillboard self, SoGetMatrixAction action)"""
        return _coin.SoVRMLBillboard_getMatrix(self, action)


    def pick(self, action):
        """pick(SoVRMLBillboard self, SoPickAction action)"""
        return _coin.SoVRMLBillboard_pick(self, action)


    def search(self, action):
        """search(SoVRMLBillboard self, SoSearchAction action)"""
        return _coin.SoVRMLBillboard_search(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderBelowPath(self, action)


    def GLRenderInPath(self, action):
        """GLRenderInPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderInPath(self, action)


    def GLRenderOffPath(self, action):
        """GLRenderOffPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderOffPath(self, action)


    def notify(self, list):
        """notify(SoVRMLBillboard self, SoNotList list)"""
        return _coin.SoVRMLBillboard_notify(self, list)

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(SoVRMLGeometry self) -> SoType"""
        return _coin.SoVRMLGeometry_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLGeometry_initClass()

    initClass = staticmethod(initClass)

    def search(self, action):
        """search(SoVRMLGeometry self, SoSearchAction action)"""
        return _coin.SoVRMLGeometry_search(self, action)


    def copyContents(self, arg2, copyConn):
        """copyContents(SoVRMLGeometry self, SoFieldContainer arg2, SbBool copyConn)"""
        return _coin.SoVRMLGeometry_copyContents(self, arg2, copyConn)

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(SoVRMLBox self) -> SoType"""
        return _coin.SoVRMLBox_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLBox_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLBox 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, action):
        """GLRender(SoVRMLBox self, SoGLRenderAction action)"""
        return _coin.SoVRMLBox_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLBox self, SoRayPickAction action)"""
        return _coin.SoVRMLBox_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLBox self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLBox_getPrimitiveCount(self, action)

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(SoVRMLGroup self) -> SoType"""
        return _coin.SoVRMLGroup_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLGroup_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoVRMLGroup self) -> SoVRMLGroup
        __init__(SoVRMLGroup 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(num):
        """setNumRenderCaches(int num)"""
        return _coin.SoVRMLGroup_setNumRenderCaches(num)

    setNumRenderCaches = staticmethod(setNumRenderCaches)

    def getNumRenderCaches():
        """getNumRenderCaches() -> int"""
        return _coin.SoVRMLGroup_getNumRenderCaches()

    getNumRenderCaches = staticmethod(getNumRenderCaches)

    def doAction(self, action):
        """doAction(SoVRMLGroup self, SoAction action)"""
        return _coin.SoVRMLGroup_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLGroup self, SoCallbackAction action)"""
        return _coin.SoVRMLGroup_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLGroup self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLGroup_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoVRMLGroup self, SoGetMatrixAction action)"""
        return _coin.SoVRMLGroup_getMatrix(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLGroup self, SoRayPickAction action)"""
        return _coin.SoVRMLGroup_rayPick(self, action)


    def search(self, action):
        """search(SoVRMLGroup self, SoSearchAction action)"""
        return _coin.SoVRMLGroup_search(self, action)


    def write(self, action):
        """write(SoVRMLGroup self, SoWriteAction action)"""
        return _coin.SoVRMLGroup_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLGroup self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLGroup_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoVRMLGroup self, SoAudioRenderAction action)"""
        return _coin.SoVRMLGroup_audioRender(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderBelowPath(self, action)


    def GLRenderInPath(self, action):
        """GLRenderInPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderInPath(self, action)


    def GLRenderOffPath(self, action):
        """GLRenderOffPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderOffPath(self, action)


    def notify(self, list):
        """notify(SoVRMLGroup self, SoNotList list)"""
        return _coin.SoVRMLGroup_notify(self, list)

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(num):
    """SoVRMLGroup_setNumRenderCaches(int num)"""
    return _coin.SoVRMLGroup_setNumRenderCaches(num)

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(SoVRMLCollision self) -> SoType"""
        return _coin.SoVRMLCollision_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLCollision_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoVRMLCollision self) -> SoVRMLCollision
        __init__(SoVRMLCollision 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, action):
        """GLRender(SoVRMLCollision self, SoGLRenderAction action)"""
        return _coin.SoVRMLCollision_GLRender(self, action)


    def notify(self, list):
        """notify(SoVRMLCollision self, SoNotList list)"""
        return _coin.SoVRMLCollision_notify(self, list)

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(SoVRMLColor self) -> SoType"""
        return _coin.SoVRMLColor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLColor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLColor 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, action):
        """doAction(SoVRMLColor self, SoAction action)"""
        return _coin.SoVRMLColor_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLColor self, SoGLRenderAction action)"""
        return _coin.SoVRMLColor_GLRender(self, action)


    def callback(self, action):
        """callback(SoVRMLColor self, SoCallbackAction action)"""
        return _coin.SoVRMLColor_callback(self, action)

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(SoVRMLInterpolator self) -> SoType"""
        return _coin.SoVRMLInterpolator_getTypeId(self)


    def getOutputData(self):
        """getOutputData(SoVRMLInterpolator 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(SoVRMLColorInterpolator self) -> SoType"""
        return _coin.SoVRMLColorInterpolator_getTypeId(self)


    def getOutputData(self):
        """getOutputData(SoVRMLColorInterpolator 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__(SoVRMLColorInterpolator 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(SoVRMLCone self) -> SoType"""
        return _coin.SoVRMLCone_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLCone_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLCone 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, action):
        """GLRender(SoVRMLCone self, SoGLRenderAction action)"""
        return _coin.SoVRMLCone_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLCone self, SoRayPickAction action)"""
        return _coin.SoVRMLCone_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLCone self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLCone_getPrimitiveCount(self, action)

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(SoVRMLCoordinate self) -> SoType"""
        return _coin.SoVRMLCoordinate_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLCoordinate_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLCoordinate 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, action):
        """doAction(SoVRMLCoordinate self, SoAction action)"""
        return _coin.SoVRMLCoordinate_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLCoordinate self, SoGLRenderAction action)"""
        return _coin.SoVRMLCoordinate_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLCoordinate self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLCoordinate_getBoundingBox(self, action)


    def callback(self, action):
        """callback(SoVRMLCoordinate self, SoCallbackAction action)"""
        return _coin.SoVRMLCoordinate_callback(self, action)


    def pick(self, action):
        """pick(SoVRMLCoordinate self, SoPickAction action)"""
        return _coin.SoVRMLCoordinate_pick(self, action)

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(SoVRMLCoordinateInterpolator self) -> SoType"""
        return _coin.SoVRMLCoordinateInterpolator_getTypeId(self)


    def getOutputData(self):
        """getOutputData(SoVRMLCoordinateInterpolator 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__(SoVRMLCoordinateInterpolator 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(SoVRMLCylinder self) -> SoType"""
        return _coin.SoVRMLCylinder_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLCylinder_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLCylinder 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, action):
        """GLRender(SoVRMLCylinder self, SoGLRenderAction action)"""
        return _coin.SoVRMLCylinder_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLCylinder self, SoRayPickAction action)"""
        return _coin.SoVRMLCylinder_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLCylinder self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLCylinder_getPrimitiveCount(self, action)

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(SoVRMLSensor 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(SoVRMLDragSensor 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, action):
        """handleEvent(SoVRMLDragSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLDragSensor_handleEvent(self, action)


    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(SoVRMLCylinderSensor self) -> SoType"""
        return _coin.SoVRMLCylinderSensor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLCylinderSensor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLCylinderSensor 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(SoVRMLLight 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, action):
        """GLRender(SoVRMLLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLLight_GLRender(self, action)

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(SoVRMLDirectionalLight self) -> SoType"""
        return _coin.SoVRMLDirectionalLight_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLDirectionalLight_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLDirectionalLight 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, action):
        """GLRender(SoVRMLDirectionalLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLDirectionalLight_GLRender(self, action)

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(SoVRMLElevationGrid self) -> SoType"""
        return _coin.SoVRMLElevationGrid_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLElevationGrid_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLElevationGrid 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, action):
        """GLRender(SoVRMLElevationGrid self, SoGLRenderAction action)"""
        return _coin.SoVRMLElevationGrid_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLElevationGrid self, SoRayPickAction action)"""
        return _coin.SoVRMLElevationGrid_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLElevationGrid self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLElevationGrid_getPrimitiveCount(self, action)

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(SoVRMLExtrusion self) -> SoType"""
        return _coin.SoVRMLExtrusion_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLExtrusion_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLExtrusion 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, action):
        """GLRender(SoVRMLExtrusion self, SoGLRenderAction action)"""
        return _coin.SoVRMLExtrusion_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLExtrusion self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLExtrusion_getPrimitiveCount(self, action)


    def computeBBox(self, action, bbox, center):
        """computeBBox(SoVRMLExtrusion self, SoAction action, SbBox3f bbox, SbVec3f center)"""
        return _coin.SoVRMLExtrusion_computeBBox(self, action, bbox, center)

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(SoVRMLFog self) -> SoType"""
        return _coin.SoVRMLFog_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLFog_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLFog 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, action):
        """GLRender(SoVRMLFog self, SoGLRenderAction action)"""
        return _coin.SoVRMLFog_GLRender(self, action)

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(SoVRMLFontStyle self) -> SoType"""
        return _coin.SoVRMLFontStyle_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLFontStyle_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLFontStyle 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(SoVRMLFontStyle self) -> SbString"""
        return _coin.SoVRMLFontStyle_getFontName(self)


    def doAction(self, action):
        """doAction(SoVRMLFontStyle self, SoAction action)"""
        return _coin.SoVRMLFontStyle_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLFontStyle self, SoCallbackAction action)"""
        return _coin.SoVRMLFontStyle_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLFontStyle self, SoGLRenderAction action)"""
        return _coin.SoVRMLFontStyle_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLFontStyle self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLFontStyle_getBoundingBox(self, action)


    def pick(self, action):
        """pick(SoVRMLFontStyle self, SoPickAction action)"""
        return _coin.SoVRMLFontStyle_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLFontStyle self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLFontStyle_getPrimitiveCount(self, action)

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(SoVRMLTexture 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, action):
        """GLRender(SoVRMLTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLTexture_GLRender(self, action)

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(SoVRMLImageTexture self) -> SoType"""
        return _coin.SoVRMLImageTexture_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLImageTexture_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLImageTexture 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(onoff):
        """setDelayFetchURL(SbBool const onoff)"""
        return _coin.SoVRMLImageTexture_setDelayFetchURL(onoff)

    setDelayFetchURL = staticmethod(setDelayFetchURL)

    def setPrequalifyFileCallBack(cb, closure):
        """setPrequalifyFileCallBack(VRMLPrequalifyFileCallback * cb, void * closure)"""
        return _coin.SoVRMLImageTexture_setPrequalifyFileCallBack(cb, closure)

    setPrequalifyFileCallBack = staticmethod(setPrequalifyFileCallBack)

    def allowPrequalifyFile(self, enable):
        """allowPrequalifyFile(SoVRMLImageTexture self, SbBool enable)"""
        return _coin.SoVRMLImageTexture_allowPrequalifyFile(self, enable)


    def doAction(self, action):
        """doAction(SoVRMLImageTexture self, SoAction action)"""
        return _coin.SoVRMLImageTexture_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLImageTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLImageTexture_GLRender(self, action)


    def callback(self, action):
        """callback(SoVRMLImageTexture self, SoCallbackAction action)"""
        return _coin.SoVRMLImageTexture_callback(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLImageTexture self, SoRayPickAction action)"""
        return _coin.SoVRMLImageTexture_rayPick(self, action)


    def setImage(self, image):
        """setImage(SoVRMLImageTexture self, SbImage image)"""
        return _coin.SoVRMLImageTexture_setImage(self, image)


    def getImage(self):
        """getImage(SoVRMLImageTexture self) -> SbImage"""
        return _coin.SoVRMLImageTexture_getImage(self)


    def setImageDataMaxAge(maxage):
        """setImageDataMaxAge(uint32_t const maxage)"""
        return _coin.SoVRMLImageTexture_setImageDataMaxAge(maxage)

    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(onoff):
    """SoVRMLImageTexture_setDelayFetchURL(SbBool const onoff)"""
    return _coin.SoVRMLImageTexture_setDelayFetchURL(onoff)

def SoVRMLImageTexture_setPrequalifyFileCallBack(cb, closure):
    """SoVRMLImageTexture_setPrequalifyFileCallBack(VRMLPrequalifyFileCallback * cb, void * closure)"""
    return _coin.SoVRMLImageTexture_setPrequalifyFileCallBack(cb, closure)

def SoVRMLImageTexture_setImageDataMaxAge(maxage):
    """SoVRMLImageTexture_setImageDataMaxAge(uint32_t const maxage)"""
    return _coin.SoVRMLImageTexture_setImageDataMaxAge(maxage)

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(SoVRMLVertexShape 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(SoVRMLVertexShape self, SoState s, SoNormalBundle nb) -> SbBool
        generateDefaultNormals(SoVRMLVertexShape self, SoState s, SoNormalCache nc) -> SbBool
        """
        return _coin.SoVRMLVertexShape_generateDefaultNormals(self, *args)


    def doAction(self, action):
        """doAction(SoVRMLVertexShape self, SoAction action)"""
        return _coin.SoVRMLVertexShape_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLVertexShape self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexShape_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLVertexShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexShape_getBoundingBox(self, action)


    def callback(self, action):
        """callback(SoVRMLVertexShape self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexShape_callback(self, action)


    def pick(self, action):
        """pick(SoVRMLVertexShape self, SoPickAction action)"""
        return _coin.SoVRMLVertexShape_pick(self, action)


    def notify(self, list):
        """notify(SoVRMLVertexShape self, SoNotList list)"""
        return _coin.SoVRMLVertexShape_notify(self, list)

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(SoVRMLIndexedShape 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(SoVRMLIndexedFaceSet self) -> SoType"""
        return _coin.SoVRMLIndexedFaceSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLIndexedFaceSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLIndexedFaceSet 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, action):
        """GLRender(SoVRMLIndexedFaceSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLIndexedFaceSet_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLIndexedFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLIndexedFaceSet_getPrimitiveCount(self, action)


    def generateDefaultNormals(self, *args):
        """
        generateDefaultNormals(SoVRMLIndexedFaceSet self, SoState s, SoNormalBundle nb) -> SbBool
        generateDefaultNormals(SoVRMLIndexedFaceSet 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(SoVRMLVertexLine 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, action):
        """doAction(SoVRMLVertexLine self, SoAction action)"""
        return _coin.SoVRMLVertexLine_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLVertexLine self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexLine_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLVertexLine self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexLine_getBoundingBox(self, action)


    def callback(self, action):
        """callback(SoVRMLVertexLine self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexLine_callback(self, action)


    def pick(self, action):
        """pick(SoVRMLVertexLine self, SoPickAction action)"""
        return _coin.SoVRMLVertexLine_pick(self, action)


    def notify(self, list):
        """notify(SoVRMLVertexLine self, SoNotList list)"""
        return _coin.SoVRMLVertexLine_notify(self, list)

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(SoVRMLIndexedLine 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(SoVRMLIndexedLineSet self) -> SoType"""
        return _coin.SoVRMLIndexedLineSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLIndexedLineSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLIndexedLineSet self) -> SoVRMLIndexedLineSet"""
        this = _coin.new_SoVRMLIndexedLineSet()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GLRender(self, action):
        """GLRender(SoVRMLIndexedLineSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLIndexedLineSet_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLIndexedLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLIndexedLineSet_getPrimitiveCount(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLIndexedLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLIndexedLineSet_getBoundingBox(self, action)

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(SoVRMLInline self) -> SoType"""
        return _coin.SoVRMLInline_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLInline_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLInline 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, url):
        """setFullURLName(SoVRMLInline self, SbString url)"""
        return _coin.SoVRMLInline_setFullURLName(self, url)


    def getFullURLName(self):
        """getFullURLName(SoVRMLInline self) -> SbString"""
        return _coin.SoVRMLInline_getFullURLName(self)


    def copyChildren(self):
        """copyChildren(SoVRMLInline self) -> SoGroup"""
        return _coin.SoVRMLInline_copyChildren(self)


    def requestURLData(self):
        """requestURLData(SoVRMLInline self)"""
        return _coin.SoVRMLInline_requestURLData(self)


    def isURLDataRequested(self):
        """isURLDataRequested(SoVRMLInline self) -> SbBool"""
        return _coin.SoVRMLInline_isURLDataRequested(self)


    def isURLDataHere(self):
        """isURLDataHere(SoVRMLInline self) -> SbBool"""
        return _coin.SoVRMLInline_isURLDataHere(self)


    def cancelURLDataRequest(self):
        """cancelURLDataRequest(SoVRMLInline self)"""
        return _coin.SoVRMLInline_cancelURLDataRequest(self)


    def setChildData(self, urlData):
        """setChildData(SoVRMLInline self, SoNode urlData)"""
        return _coin.SoVRMLInline_setChildData(self, urlData)


    def getChildData(self):
        """getChildData(SoVRMLInline self) -> SoNode"""
        return _coin.SoVRMLInline_getChildData(self)


    def setFetchURLCallBack(f, closure):
        """setFetchURLCallBack(SoVRMLInlineFetchURLCB * f, void * closure)"""
        return _coin.SoVRMLInline_setFetchURLCallBack(f, closure)

    setFetchURLCallBack = staticmethod(setFetchURLCallBack)

    def setBoundingBoxVisibility(b):
        """setBoundingBoxVisibility(SoVRMLInline::BboxVisibility b)"""
        return _coin.SoVRMLInline_setBoundingBoxVisibility(b)

    setBoundingBoxVisibility = staticmethod(setBoundingBoxVisibility)

    def getBoundingBoxVisibility():
        """getBoundingBoxVisibility() -> SoVRMLInline::BboxVisibility"""
        return _coin.SoVRMLInline_getBoundingBoxVisibility()

    getBoundingBoxVisibility = staticmethod(getBoundingBoxVisibility)

    def setBoundingBoxColor(color):
        """setBoundingBoxColor(SbColor color)"""
        return _coin.SoVRMLInline_setBoundingBoxColor(color)

    setBoundingBoxColor = staticmethod(setBoundingBoxColor)

    def getBoundingBoxColor():
        """getBoundingBoxColor() -> SbColor"""
        return _coin.SoVRMLInline_getBoundingBoxColor()

    getBoundingBoxColor = staticmethod(getBoundingBoxColor)

    def setReadAsSoFile(enable):
        """setReadAsSoFile(SbBool enable)"""
        return _coin.SoVRMLInline_setReadAsSoFile(enable)

    setReadAsSoFile = staticmethod(setReadAsSoFile)

    def getReadAsSoFile():
        """getReadAsSoFile() -> SbBool"""
        return _coin.SoVRMLInline_getReadAsSoFile()

    getReadAsSoFile = staticmethod(getReadAsSoFile)

    def doAction(self, action):
        """doAction(SoVRMLInline self, SoAction action)"""
        return _coin.SoVRMLInline_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLInline self, SoCallbackAction action)"""
        return _coin.SoVRMLInline_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLInline self, SoGLRenderAction action)"""
        return _coin.SoVRMLInline_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLInline self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLInline_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoVRMLInline self, SoGetMatrixAction action)"""
        return _coin.SoVRMLInline_getMatrix(self, action)


    def handleEvent(self, action):
        """handleEvent(SoVRMLInline self, SoHandleEventAction action)"""
        return _coin.SoVRMLInline_handleEvent(self, action)


    def search(self, action):
        """search(SoVRMLInline self, SoSearchAction action)"""
        return _coin.SoVRMLInline_search(self, action)


    def pick(self, action):
        """pick(SoVRMLInline self, SoPickAction action)"""
        return _coin.SoVRMLInline_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLInline self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLInline_getPrimitiveCount(self, action)


    def getChildren(self):
        """getChildren(SoVRMLInline 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(f, closure):
    """SoVRMLInline_setFetchURLCallBack(SoVRMLInlineFetchURLCB * f, void * closure)"""
    return _coin.SoVRMLInline_setFetchURLCallBack(f, closure)

def SoVRMLInline_setBoundingBoxVisibility(b):
    """SoVRMLInline_setBoundingBoxVisibility(SoVRMLInline::BboxVisibility b)"""
    return _coin.SoVRMLInline_setBoundingBoxVisibility(b)

def SoVRMLInline_getBoundingBoxVisibility():
    """SoVRMLInline_getBoundingBoxVisibility() -> SoVRMLInline::BboxVisibility"""
    return _coin.SoVRMLInline_getBoundingBoxVisibility()

def SoVRMLInline_setBoundingBoxColor(color):
    """SoVRMLInline_setBoundingBoxColor(SbColor color)"""
    return _coin.SoVRMLInline_setBoundingBoxColor(color)

def SoVRMLInline_getBoundingBoxColor():
    """SoVRMLInline_getBoundingBoxColor() -> SbColor"""
    return _coin.SoVRMLInline_getBoundingBoxColor()

def SoVRMLInline_setReadAsSoFile(enable):
    """SoVRMLInline_setReadAsSoFile(SbBool enable)"""
    return _coin.SoVRMLInline_setReadAsSoFile(enable)

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(SoVRMLLOD self) -> SoType"""
        return _coin.SoVRMLLOD_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLLOD_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoVRMLLOD self) -> SoVRMLLOD
        __init__(SoVRMLLOD 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(SoVRMLLOD self) -> SbBool"""
        return _coin.SoVRMLLOD_affectsState(self)


    def addLevel(self, level):
        """addLevel(SoVRMLLOD self, SoNode level)"""
        return _coin.SoVRMLLOD_addLevel(self, level)


    def insertLevel(self, level, idx):
        """insertLevel(SoVRMLLOD self, SoNode level, int idx)"""
        return _coin.SoVRMLLOD_insertLevel(self, level, idx)


    def getLevel(self, idx):
        """getLevel(SoVRMLLOD self, int idx) -> SoNode"""
        return _coin.SoVRMLLOD_getLevel(self, idx)


    def findLevel(self, level):
        """findLevel(SoVRMLLOD self, SoNode level) -> int"""
        return _coin.SoVRMLLOD_findLevel(self, level)


    def getNumLevels(self):
        """getNumLevels(SoVRMLLOD self) -> int"""
        return _coin.SoVRMLLOD_getNumLevels(self)


    def removeLevel(self, *args):
        """
        removeLevel(SoVRMLLOD self, int idx)
        removeLevel(SoVRMLLOD self, SoNode level)
        """
        return _coin.SoVRMLLOD_removeLevel(self, *args)


    def removeAllLevels(self):
        """removeAllLevels(SoVRMLLOD self)"""
        return _coin.SoVRMLLOD_removeAllLevels(self)


    def replaceLevel(self, *args):
        """
        replaceLevel(SoVRMLLOD self, int idx, SoNode level)
        replaceLevel(SoVRMLLOD self, SoNode old, SoNode level)
        """
        return _coin.SoVRMLLOD_replaceLevel(self, *args)


    def doAction(self, action):
        """doAction(SoVRMLLOD self, SoAction action)"""
        return _coin.SoVRMLLOD_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLLOD self, SoCallbackAction action)"""
        return _coin.SoVRMLLOD_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLLOD self, SoRayPickAction action)"""
        return _coin.SoVRMLLOD_rayPick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLLOD self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLLOD_getBoundingBox(self, action)


    def search(self, action):
        """search(SoVRMLLOD self, SoSearchAction action)"""
        return _coin.SoVRMLLOD_search(self, action)


    def write(self, action):
        """write(SoVRMLLOD self, SoWriteAction action)"""
        return _coin.SoVRMLLOD_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLLOD self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLLOD_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoVRMLLOD self, SoAudioRenderAction action)"""
        return _coin.SoVRMLLOD_audioRender(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderBelowPath(self, action)


    def GLRenderInPath(self, action):
        """GLRenderInPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderInPath(self, action)


    def GLRenderOffPath(self, action):
        """GLRenderOffPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderOffPath(self, action)


    def addChild(self, child):
        """addChild(SoVRMLLOD self, SoNode child)"""
        return _coin.SoVRMLLOD_addChild(self, child)


    def insertChild(self, child, idx):
        """insertChild(SoVRMLLOD self, SoNode child, int idx)"""
        return _coin.SoVRMLLOD_insertChild(self, child, idx)


    def getChild(self, idx):
        """getChild(SoVRMLLOD self, int idx) -> SoNode"""
        return _coin.SoVRMLLOD_getChild(self, idx)


    def findChild(self, child):
        """findChild(SoVRMLLOD self, SoNode child) -> int"""
        return _coin.SoVRMLLOD_findChild(self, child)


    def getNumChildren(self):
        """getNumChildren(SoVRMLLOD self) -> int"""
        return _coin.SoVRMLLOD_getNumChildren(self)


    def removeChild(self, *args):
        """
        removeChild(SoVRMLLOD self, int idx)
        removeChild(SoVRMLLOD self, SoNode child)
        """
        return _coin.SoVRMLLOD_removeChild(self, *args)


    def removeAllChildren(self):
        """removeAllChildren(SoVRMLLOD self)"""
        return _coin.SoVRMLLOD_removeAllChildren(self)


    def replaceChild(self, *args):
        """
        replaceChild(SoVRMLLOD self, int idx, SoNode child)
        replaceChild(SoVRMLLOD self, SoNode old, SoNode child)
        """
        return _coin.SoVRMLLOD_replaceChild(self, *args)


    def getChildren(self):
        """getChildren(SoVRMLLOD 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(SoVRMLMaterial self) -> SoType"""
        return _coin.SoVRMLMaterial_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLMaterial_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLMaterial 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, action):
        """doAction(SoVRMLMaterial self, SoAction action)"""
        return _coin.SoVRMLMaterial_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLMaterial self, SoGLRenderAction action)"""
        return _coin.SoVRMLMaterial_GLRender(self, action)


    def callback(self, action):
        """callback(SoVRMLMaterial self, SoCallbackAction action)"""
        return _coin.SoVRMLMaterial_callback(self, action)

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(SoVRMLMovieTexture self) -> SoType"""
        return _coin.SoVRMLMovieTexture_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLMovieTexture_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLMovieTexture 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, action):
        """GLRender(SoVRMLMovieTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLMovieTexture_GLRender(self, action)

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(SoVRMLNavigationInfo self) -> SoType"""
        return _coin.SoVRMLNavigationInfo_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLNavigationInfo_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLNavigationInfo 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, action):
        """GLRender(SoVRMLNavigationInfo self, SoGLRenderAction action)"""
        return _coin.SoVRMLNavigationInfo_GLRender(self, action)

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(SoVRMLNormal self) -> SoType"""
        return _coin.SoVRMLNormal_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLNormal_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLNormal 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, action):
        """doAction(SoVRMLNormal self, SoAction action)"""
        return _coin.SoVRMLNormal_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLNormal self, SoGLRenderAction action)"""
        return _coin.SoVRMLNormal_GLRender(self, action)


    def callback(self, action):
        """callback(SoVRMLNormal self, SoCallbackAction action)"""
        return _coin.SoVRMLNormal_callback(self, action)


    def pick(self, action):
        """pick(SoVRMLNormal self, SoPickAction action)"""
        return _coin.SoVRMLNormal_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLNormal self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLNormal_getPrimitiveCount(self, action)

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(SoVRMLNormalInterpolator self) -> SoType"""
        return _coin.SoVRMLNormalInterpolator_getTypeId(self)


    def getOutputData(self):
        """getOutputData(SoVRMLNormalInterpolator 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__(SoVRMLNormalInterpolator 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(SoVRMLOrientationInterpolator self) -> SoType"""
        return _coin.SoVRMLOrientationInterpolator_getTypeId(self)


    def getOutputData(self):
        """getOutputData(SoVRMLOrientationInterpolator 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__(SoVRMLOrientationInterpolator 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(SoVRMLPixelTexture self) -> SoType"""
        return _coin.SoVRMLPixelTexture_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLPixelTexture_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLPixelTexture 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, action):
        """doAction(SoVRMLPixelTexture self, SoAction action)"""
        return _coin.SoVRMLPixelTexture_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLPixelTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLPixelTexture_GLRender(self, action)


    def callback(self, action):
        """callback(SoVRMLPixelTexture self, SoCallbackAction action)"""
        return _coin.SoVRMLPixelTexture_callback(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLPixelTexture self, SoRayPickAction action)"""
        return _coin.SoVRMLPixelTexture_rayPick(self, action)

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(SoVRMLPlaneSensor self) -> SoType"""
        return _coin.SoVRMLPlaneSensor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLPlaneSensor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLPlaneSensor 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(SoVRMLPointLight self) -> SoType"""
        return _coin.SoVRMLPointLight_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLPointLight_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLPointLight 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, action):
        """GLRender(SoVRMLPointLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLPointLight_GLRender(self, action)

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(SoVRMLVertexPoint 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, action):
        """doAction(SoVRMLVertexPoint self, SoAction action)"""
        return _coin.SoVRMLVertexPoint_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLVertexPoint self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexPoint_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLVertexPoint self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexPoint_getBoundingBox(self, action)


    def callback(self, action):
        """callback(SoVRMLVertexPoint self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexPoint_callback(self, action)


    def pick(self, action):
        """pick(SoVRMLVertexPoint self, SoPickAction action)"""
        return _coin.SoVRMLVertexPoint_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLVertexPoint self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLVertexPoint_getPrimitiveCount(self, action)


    def notify(self, list):
        """notify(SoVRMLVertexPoint self, SoNotList list)"""
        return _coin.SoVRMLVertexPoint_notify(self, list)

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(SoVRMLPointSet self) -> SoType"""
        return _coin.SoVRMLPointSet_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLPointSet_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLPointSet self) -> SoVRMLPointSet"""
        this = _coin.new_SoVRMLPointSet()
        try:
            self.this.append(this)
        except:
            self.this = this

    def GLRender(self, action):
        """GLRender(SoVRMLPointSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLPointSet_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLPointSet_getBoundingBox(self, action)

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(SoVRMLPositionInterpolator self) -> SoType"""
        return _coin.SoVRMLPositionInterpolator_getTypeId(self)


    def getOutputData(self):
        """getOutputData(SoVRMLPositionInterpolator 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__(SoVRMLPositionInterpolator 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(SoVRMLProximitySensor self) -> SoType"""
        return _coin.SoVRMLProximitySensor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLProximitySensor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLProximitySensor 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(SoVRMLProximitySensor self) -> SbBool"""
        return _coin.SoVRMLProximitySensor_affectsState(self)


    def doAction(self, action):
        """doAction(SoVRMLProximitySensor self, SoAction action)"""
        return _coin.SoVRMLProximitySensor_doAction(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLProximitySensor self, SoGLRenderAction action)"""
        return _coin.SoVRMLProximitySensor_GLRender(self, action)


    def callback(self, action):
        """callback(SoVRMLProximitySensor self, SoCallbackAction action)"""
        return _coin.SoVRMLProximitySensor_callback(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLProximitySensor self, SoRayPickAction action)"""
        return _coin.SoVRMLProximitySensor_rayPick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLProximitySensor self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLProximitySensor_getBoundingBox(self, action)

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(SoVRMLScalarInterpolator self) -> SoType"""
        return _coin.SoVRMLScalarInterpolator_getTypeId(self)


    def getOutputData(self):
        """getOutputData(SoVRMLScalarInterpolator 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__(SoVRMLScalarInterpolator 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__(SoVRMLScript 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(SoVRMLScript 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, action):
        """doAction(SoVRMLScript self, SoAction action)"""
        return _coin.SoVRMLScript_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLScript self, SoCallbackAction action)"""
        return _coin.SoVRMLScript_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLScript self, SoGLRenderAction action)"""
        return _coin.SoVRMLScript_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLScript self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLScript_getBoundingBox(self, action)


    def pick(self, action):
        """pick(SoVRMLScript self, SoPickAction action)"""
        return _coin.SoVRMLScript_pick(self, action)


    def handleEvent(self, action):
        """handleEvent(SoVRMLScript self, SoHandleEventAction action)"""
        return _coin.SoVRMLScript_handleEvent(self, action)


    def write(self, action):
        """write(SoVRMLScript self, SoWriteAction action)"""
        return _coin.SoVRMLScript_write(self, action)


    def setScriptEvaluateCB(cb, closure):
        """setScriptEvaluateCB(SoVRMLScriptEvaluateCB * cb, void * closure)"""
        return _coin.SoVRMLScript_setScriptEvaluateCB(cb, closure)

    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(cb, closure):
    """SoVRMLScript_setScriptEvaluateCB(SoVRMLScriptEvaluateCB * cb, void * closure)"""
    return _coin.SoVRMLScript_setScriptEvaluateCB(cb, closure)

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(SoVRMLShape self) -> SoType"""
        return _coin.SoVRMLShape_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLShape_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLShape 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(num):
        """setNumRenderCaches(int num)"""
        return _coin.SoVRMLShape_setNumRenderCaches(num)

    setNumRenderCaches = staticmethod(setNumRenderCaches)

    def getNumRenderCaches():
        """getNumRenderCaches() -> int"""
        return _coin.SoVRMLShape_getNumRenderCaches()

    getNumRenderCaches = staticmethod(getNumRenderCaches)

    def affectsState(self):
        """affectsState(SoVRMLShape self) -> SbBool"""
        return _coin.SoVRMLShape_affectsState(self)


    def doAction(self, action):
        """doAction(SoVRMLShape self, SoAction action)"""
        return _coin.SoVRMLShape_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLShape self, SoCallbackAction action)"""
        return _coin.SoVRMLShape_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLShape self, SoGLRenderAction action)"""
        return _coin.SoVRMLShape_GLRender(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLShape_getBoundingBox(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLShape self, SoRayPickAction action)"""
        return _coin.SoVRMLShape_rayPick(self, action)


    def search(self, action):
        """search(SoVRMLShape self, SoSearchAction action)"""
        return _coin.SoVRMLShape_search(self, action)


    def write(self, action):
        """write(SoVRMLShape self, SoWriteAction action)"""
        return _coin.SoVRMLShape_write(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLShape self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLShape_getPrimitiveCount(self, action)


    def getChildren(self):
        """getChildren(SoVRMLShape self) -> SoChildList"""
        return _coin.SoVRMLShape_getChildren(self)


    def notify(self, list):
        """notify(SoVRMLShape self, SoNotList list)"""
        return _coin.SoVRMLShape_notify(self, list)


    def copyContents(self, arg2, copyConn):
        """copyContents(SoVRMLShape self, SoFieldContainer arg2, SbBool copyConn)"""
        return _coin.SoVRMLShape_copyContents(self, arg2, copyConn)

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(num):
    """SoVRMLShape_setNumRenderCaches(int num)"""
    return _coin.SoVRMLShape_setNumRenderCaches(num)

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(SoVRMLSound self) -> SoType"""
        return _coin.SoVRMLSound_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLSound_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLSound 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, velocity):
        """setDopplerVelocity(SoVRMLSound self, float velocity)"""
        return _coin.SoVRMLSound_setDopplerVelocity(self, velocity)


    def getDopplerVelocity(self):
        """getDopplerVelocity(SoVRMLSound self) -> float"""
        return _coin.SoVRMLSound_getDopplerVelocity(self)


    def setDopplerFactor(self, factor):
        """setDopplerFactor(SoVRMLSound self, float factor)"""
        return _coin.SoVRMLSound_setDopplerFactor(self, factor)


    def getDopplerFactor(self):
        """getDopplerFactor(SoVRMLSound self) -> float"""
        return _coin.SoVRMLSound_getDopplerFactor(self)


    def startPlaying(self, path, userdataptr):
        """startPlaying(SoVRMLSound self, SoPath path, void * userdataptr)"""
        return _coin.SoVRMLSound_startPlaying(self, path, userdataptr)


    def stopPlaying(self, path, userdataptr):
        """stopPlaying(SoVRMLSound self, SoPath path, void * userdataptr)"""
        return _coin.SoVRMLSound_stopPlaying(self, path, userdataptr)


    def setDefaultBufferingProperties(bufferLength, numBuffers, sleepTime):
        """setDefaultBufferingProperties(int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_setDefaultBufferingProperties(bufferLength, numBuffers, sleepTime)

    setDefaultBufferingProperties = staticmethod(setDefaultBufferingProperties)

    def setBufferingProperties(self, bufferLength, numBuffers, sleepTime):
        """setBufferingProperties(SoVRMLSound self, int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_setBufferingProperties(self, bufferLength, numBuffers, sleepTime)


    def getBufferingProperties(self, bufferLength, numBuffers, sleepTime):
        """getBufferingProperties(SoVRMLSound self, int & bufferLength, int & numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_getBufferingProperties(self, bufferLength, numBuffers, sleepTime)


    def audioRender(self, action):
        """audioRender(SoVRMLSound self, SoAudioRenderAction action)"""
        return _coin.SoVRMLSound_audioRender(self, action)

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(bufferLength, numBuffers, sleepTime):
    """SoVRMLSound_setDefaultBufferingProperties(int bufferLength, int numBuffers, SbTime sleepTime)"""
    return _coin.SoVRMLSound_setDefaultBufferingProperties(bufferLength, numBuffers, sleepTime)

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(SoVRMLSphere self) -> SoType"""
        return _coin.SoVRMLSphere_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLSphere_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLSphere 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, action):
        """GLRender(SoVRMLSphere self, SoGLRenderAction action)"""
        return _coin.SoVRMLSphere_GLRender(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLSphere self, SoRayPickAction action)"""
        return _coin.SoVRMLSphere_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLSphere self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLSphere_getPrimitiveCount(self, action)

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(SoVRMLSphereSensor self) -> SoType"""
        return _coin.SoVRMLSphereSensor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLSphereSensor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLSphereSensor 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(SoVRMLSpotLight self) -> SoType"""
        return _coin.SoVRMLSpotLight_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLSpotLight_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLSpotLight 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, action):
        """GLRender(SoVRMLSpotLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLSpotLight_GLRender(self, action)

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(SoVRMLSwitch self) -> SoType"""
        return _coin.SoVRMLSwitch_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLSwitch_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoVRMLSwitch self) -> SoVRMLSwitch
        __init__(SoVRMLSwitch 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(SoVRMLSwitch self) -> SbBool"""
        return _coin.SoVRMLSwitch_affectsState(self)


    def addChoice(self, choice):
        """addChoice(SoVRMLSwitch self, SoNode choice)"""
        return _coin.SoVRMLSwitch_addChoice(self, choice)


    def insertChoice(self, choice, idx):
        """insertChoice(SoVRMLSwitch self, SoNode choice, int idx)"""
        return _coin.SoVRMLSwitch_insertChoice(self, choice, idx)


    def getChoice(self, idx):
        """getChoice(SoVRMLSwitch self, int idx) -> SoNode"""
        return _coin.SoVRMLSwitch_getChoice(self, idx)


    def findChoice(self, choice):
        """findChoice(SoVRMLSwitch self, SoNode choice) -> int"""
        return _coin.SoVRMLSwitch_findChoice(self, choice)


    def getNumChoices(self):
        """getNumChoices(SoVRMLSwitch self) -> int"""
        return _coin.SoVRMLSwitch_getNumChoices(self)


    def removeChoice(self, *args):
        """
        removeChoice(SoVRMLSwitch self, int idx)
        removeChoice(SoVRMLSwitch self, SoNode node)
        """
        return _coin.SoVRMLSwitch_removeChoice(self, *args)


    def removeAllChoices(self):
        """removeAllChoices(SoVRMLSwitch self)"""
        return _coin.SoVRMLSwitch_removeAllChoices(self)


    def replaceChoice(self, *args):
        """
        replaceChoice(SoVRMLSwitch self, int idx, SoNode choice)
        replaceChoice(SoVRMLSwitch self, SoNode old, SoNode choice)
        """
        return _coin.SoVRMLSwitch_replaceChoice(self, *args)


    def doAction(self, action):
        """doAction(SoVRMLSwitch self, SoAction action)"""
        return _coin.SoVRMLSwitch_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLSwitch self, SoCallbackAction action)"""
        return _coin.SoVRMLSwitch_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLSwitch self, SoGLRenderAction action)"""
        return _coin.SoVRMLSwitch_GLRender(self, action)


    def pick(self, action):
        """pick(SoVRMLSwitch self, SoPickAction action)"""
        return _coin.SoVRMLSwitch_pick(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLSwitch_getBoundingBox(self, action)


    def handleEvent(self, action):
        """handleEvent(SoVRMLSwitch self, SoHandleEventAction action)"""
        return _coin.SoVRMLSwitch_handleEvent(self, action)


    def getMatrix(self, action):
        """getMatrix(SoVRMLSwitch self, SoGetMatrixAction action)"""
        return _coin.SoVRMLSwitch_getMatrix(self, action)


    def search(self, action):
        """search(SoVRMLSwitch self, SoSearchAction action)"""
        return _coin.SoVRMLSwitch_search(self, action)


    def write(self, action):
        """write(SoVRMLSwitch self, SoWriteAction action)"""
        return _coin.SoVRMLSwitch_write(self, action)


    def audioRender(self, action):
        """audioRender(SoVRMLSwitch self, SoAudioRenderAction action)"""
        return _coin.SoVRMLSwitch_audioRender(self, action)


    def addChild(self, child):
        """addChild(SoVRMLSwitch self, SoNode child)"""
        return _coin.SoVRMLSwitch_addChild(self, child)


    def insertChild(self, child, idx):
        """insertChild(SoVRMLSwitch self, SoNode child, int idx)"""
        return _coin.SoVRMLSwitch_insertChild(self, child, idx)


    def getChild(self, idx):
        """getChild(SoVRMLSwitch self, int idx) -> SoNode"""
        return _coin.SoVRMLSwitch_getChild(self, idx)


    def findChild(self, child):
        """findChild(SoVRMLSwitch self, SoNode child) -> int"""
        return _coin.SoVRMLSwitch_findChild(self, child)


    def getNumChildren(self):
        """getNumChildren(SoVRMLSwitch self) -> int"""
        return _coin.SoVRMLSwitch_getNumChildren(self)


    def removeChild(self, *args):
        """
        removeChild(SoVRMLSwitch self, int idx)
        removeChild(SoVRMLSwitch self, SoNode child)
        """
        return _coin.SoVRMLSwitch_removeChild(self, *args)


    def removeAllChildren(self):
        """removeAllChildren(SoVRMLSwitch self)"""
        return _coin.SoVRMLSwitch_removeAllChildren(self)


    def replaceChild(self, *args):
        """
        replaceChild(SoVRMLSwitch self, int idx, SoNode node)
        replaceChild(SoVRMLSwitch self, SoNode old, SoNode node)
        """
        return _coin.SoVRMLSwitch_replaceChild(self, *args)


    def getChildren(self):
        """getChildren(SoVRMLSwitch 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(SoVRMLText self) -> SoType"""
        return _coin.SoVRMLText_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLText_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLText 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, action):
        """GLRender(SoVRMLText self, SoGLRenderAction action)"""
        return _coin.SoVRMLText_GLRender(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLText self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLText_getPrimitiveCount(self, action)


    def notify(self, list):
        """notify(SoVRMLText self, SoNotList list)"""
        return _coin.SoVRMLText_notify(self, list)


    def getChildren(self):
        """getChildren(SoVRMLText 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(SoVRMLTextureCoordinate self) -> SoType"""
        return _coin.SoVRMLTextureCoordinate_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLTextureCoordinate_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLTextureCoordinate 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, action):
        """doAction(SoVRMLTextureCoordinate self, SoAction action)"""
        return _coin.SoVRMLTextureCoordinate_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLTextureCoordinate self, SoCallbackAction action)"""
        return _coin.SoVRMLTextureCoordinate_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLTextureCoordinate self, SoGLRenderAction action)"""
        return _coin.SoVRMLTextureCoordinate_GLRender(self, action)


    def pick(self, action):
        """pick(SoVRMLTextureCoordinate self, SoPickAction action)"""
        return _coin.SoVRMLTextureCoordinate_pick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLTextureCoordinate self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLTextureCoordinate_getPrimitiveCount(self, action)

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(SoVRMLTextureTransform self) -> SoType"""
        return _coin.SoVRMLTextureTransform_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLTextureTransform_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLTextureTransform 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, action):
        """doAction(SoVRMLTextureTransform self, SoAction action)"""
        return _coin.SoVRMLTextureTransform_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLTextureTransform self, SoCallbackAction action)"""
        return _coin.SoVRMLTextureTransform_callback(self, action)


    def GLRender(self, action):
        """GLRender(SoVRMLTextureTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTextureTransform_GLRender(self, action)


    def getMatrix(self, action):
        """getMatrix(SoVRMLTextureTransform self, SoGetMatrixAction action)"""
        return _coin.SoVRMLTextureTransform_getMatrix(self, action)


    def pick(self, action):
        """pick(SoVRMLTextureTransform self, SoPickAction action)"""
        return _coin.SoVRMLTextureTransform_pick(self, action)

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(SoVRMLTimeSensor self) -> SoType"""
        return _coin.SoVRMLTimeSensor_getTypeId(self)


    def getOutputData(self):
        """getOutputData(SoVRMLTimeSensor 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__(SoVRMLTimeSensor 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, list):
        """notify(SoVRMLTimeSensor self, SoNotList list)"""
        return _coin.SoVRMLTimeSensor_notify(self, list)


    def handleEvent(self, action):
        """handleEvent(SoVRMLTimeSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLTimeSensor_handleEvent(self, action)


    def write(self, action):
        """write(SoVRMLTimeSensor self, SoWriteAction action)"""
        return _coin.SoVRMLTimeSensor_write(self, action)

    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(SoVRMLTouchSensor self) -> SoType"""
        return _coin.SoVRMLTouchSensor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLTouchSensor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLTouchSensor 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(SoVRMLTouchSensor self) -> SbBool"""
        return _coin.SoVRMLTouchSensor_affectsState(self)


    def handleEvent(self, action):
        """handleEvent(SoVRMLTouchSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLTouchSensor_handleEvent(self, action)

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(SoVRMLTransform self) -> SoType"""
        return _coin.SoVRMLTransform_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLTransform_initClass()

    initClass = staticmethod(initClass)

    def __init__(self, *args):
        """
        __init__(SoVRMLTransform self) -> SoVRMLTransform
        __init__(SoVRMLTransform 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, arg2, to):
        """pointAt(SoVRMLTransform self, SbVec3f arg2, SbVec3f to)"""
        return _coin.SoVRMLTransform_pointAt(self, arg2, to)


    def getScaleSpaceMatrix(self, inverse):
        """getScaleSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getScaleSpaceMatrix(self, inverse)


    def getRotationSpaceMatrix(self, inverse):
        """getRotationSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getRotationSpaceMatrix(self, inverse)


    def getTranslationSpaceMatrix(self, inverse):
        """getTranslationSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getTranslationSpaceMatrix(self, inverse)


    def multLeft(self):
        """multLeft(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_multLeft(self)


    def multRight(self):
        """multRight(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_multRight(self)


    def combineLeft(self, leftnode):
        """combineLeft(SoVRMLTransform self, SoVRMLTransform leftnode)"""
        return _coin.SoVRMLTransform_combineLeft(self, leftnode)


    def combineRight(self, rightnode):
        """combineRight(SoVRMLTransform self, SoVRMLTransform rightnode)"""
        return _coin.SoVRMLTransform_combineRight(self, rightnode)


    def setMatrix(self):
        """setMatrix(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_setMatrix(self)


    def recenter(self, newcenter):
        """recenter(SoVRMLTransform self, SbVec3f newcenter)"""
        return _coin.SoVRMLTransform_recenter(self, newcenter)


    def doAction(self, action):
        """doAction(SoVRMLTransform self, SoAction action)"""
        return _coin.SoVRMLTransform_doAction(self, action)


    def callback(self, action):
        """callback(SoVRMLTransform self, SoCallbackAction action)"""
        return _coin.SoVRMLTransform_callback(self, action)


    def getBoundingBox(self, action):
        """getBoundingBox(SoVRMLTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLTransform_getBoundingBox(self, action)


    def getMatrix(self, action):
        """getMatrix(SoVRMLTransform self, SoGetMatrixAction action)"""
        return _coin.SoVRMLTransform_getMatrix(self, action)


    def rayPick(self, action):
        """rayPick(SoVRMLTransform self, SoRayPickAction action)"""
        return _coin.SoVRMLTransform_rayPick(self, action)


    def getPrimitiveCount(self, action):
        """getPrimitiveCount(SoVRMLTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLTransform_getPrimitiveCount(self, action)


    def audioRender(self, action):
        """audioRender(SoVRMLTransform self, SoAudioRenderAction action)"""
        return _coin.SoVRMLTransform_audioRender(self, action)


    def GLRenderBelowPath(self, action):
        """GLRenderBelowPath(SoVRMLTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTransform_GLRenderBelowPath(self, action)


    def GLRenderInPath(self, action):
        """GLRenderInPath(SoVRMLTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTransform_GLRenderInPath(self, action)


    def notify(self, list):
        """notify(SoVRMLTransform self, SoNotList list)"""
        return _coin.SoVRMLTransform_notify(self, list)

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(SoVRMLViewpoint self) -> SoType"""
        return _coin.SoVRMLViewpoint_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLViewpoint_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLViewpoint 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, action):
        """GLRender(SoVRMLViewpoint self, SoGLRenderAction action)"""
        return _coin.SoVRMLViewpoint_GLRender(self, action)

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(SoVRMLVisibilitySensor self) -> SoType"""
        return _coin.SoVRMLVisibilitySensor_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLVisibilitySensor_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLVisibilitySensor 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, action):
        """GLRender(SoVRMLVisibilitySensor self, SoGLRenderAction action)"""
        return _coin.SoVRMLVisibilitySensor_GLRender(self, action)

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(SoVRMLWorldInfo self) -> SoType"""
        return _coin.SoVRMLWorldInfo_getTypeId(self)


    def initClass():
        """initClass()"""
        return _coin.SoVRMLWorldInfo_initClass()

    initClass = staticmethod(initClass)

    def __init__(self):
        """__init__(SoVRMLWorldInfo 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__(SoEventManager 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, sceneroot):
        """setSceneGraph(SoEventManager self, SoNode sceneroot)"""
        return _coin.SoEventManager_setSceneGraph(self, sceneroot)


    def getSceneGraph(self):
        """getSceneGraph(SoEventManager self) -> SoNode"""
        return _coin.SoEventManager_getSceneGraph(self)


    def setCamera(self, camera):
        """setCamera(SoEventManager self, SoCamera camera)"""
        return _coin.SoEventManager_setCamera(self, camera)


    def getCamera(self):
        """getCamera(SoEventManager self) -> SoCamera"""
        return _coin.SoEventManager_getCamera(self)


    def processEvent(self, event):
        """processEvent(SoEventManager self, SoEvent event) -> SbBool"""
        return _coin.SoEventManager_processEvent(self, event)


    def setNavigationState(self, state):
        """setNavigationState(SoEventManager self, SoEventManager::NavigationState state)"""
        return _coin.SoEventManager_setNavigationState(self, state)


    def getNavigationState(self):
        """getNavigationState(SoEventManager self) -> SoEventManager::NavigationState"""
        return _coin.SoEventManager_getNavigationState(self)


    def getNumSoScXMLStateMachines(self):
        """getNumSoScXMLStateMachines(SoEventManager self) -> int"""
        return _coin.SoEventManager_getNumSoScXMLStateMachines(self)


    def getSoScXMLStateMachine(self, idx):
        """getSoScXMLStateMachine(SoEventManager self, int idx) -> SoScXMLStateMachine"""
        return _coin.SoEventManager_getSoScXMLStateMachine(self, idx)


    def addSoScXMLStateMachine(self, sm):
        """addSoScXMLStateMachine(SoEventManager self, SoScXMLStateMachine sm)"""
        return _coin.SoEventManager_addSoScXMLStateMachine(self, sm)


    def removeSoScXMLStateMachine(self, sm):
        """removeSoScXMLStateMachine(SoEventManager self, SoScXMLStateMachine sm)"""
        return _coin.SoEventManager_removeSoScXMLStateMachine(self, sm)


    def setSize(self, newsize):
        """setSize(SoEventManager self, SbVec2s newsize)"""
        return _coin.SoEventManager_setSize(self, newsize)


    def setOrigin(self, newOrigin):
        """setOrigin(SoEventManager self, SbVec2s newOrigin)"""
        return _coin.SoEventManager_setOrigin(self, newOrigin)


    def setViewportRegion(self, newregion):
        """setViewportRegion(SoEventManager self, SbViewportRegion newregion)"""
        return _coin.SoEventManager_setViewportRegion(self, newregion)


    def getViewportRegion(self):
        """getViewportRegion(SoEventManager self) -> SbViewportRegion"""
        return _coin.SoEventManager_getViewportRegion(self)


    def setHandleEventAction(self, hea):
        """setHandleEventAction(SoEventManager self, SoHandleEventAction hea)"""
        return _coin.SoEventManager_setHandleEventAction(self, hea)


    def getHandleEventAction(self):
        """getHandleEventAction(SoEventManager 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__(SoRenderManager 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(SoRenderManager self, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        render(SoRenderManager self, SbBool const clearwindow=1)
        render(SoRenderManager self)
        render(SoRenderManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        render(SoRenderManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1)
        render(SoRenderManager self, SoGLRenderAction action, SbBool const initmatrices=1)
        render(SoRenderManager self, SoGLRenderAction action)
        """
        return _coin.SoRenderManager_render(self, *args)


    def addSuperimposition(self, *args):
        """
        addSuperimposition(SoRenderManager self, SoNode scene, uint32_t flags) -> SoRenderManager::Superimposition
        addSuperimposition(SoRenderManager self, SoNode scene) -> SoRenderManager::Superimposition *
        """
        return _coin.SoRenderManager_addSuperimposition(self, *args)


    def removeSuperimposition(self, s):
        """removeSuperimposition(SoRenderManager self, SoRenderManager::Superimposition * s)"""
        return _coin.SoRenderManager_removeSuperimposition(self, s)


    def setSceneGraph(self, sceneroot):
        """setSceneGraph(SoRenderManager self, SoNode sceneroot)"""
        return _coin.SoRenderManager_setSceneGraph(self, sceneroot)


    def getSceneGraph(self):
        """getSceneGraph(SoRenderManager self) -> SoNode"""
        return _coin.SoRenderManager_getSceneGraph(self)


    def setCamera(self, camera):
        """setCamera(SoRenderManager self, SoCamera camera)"""
        return _coin.SoRenderManager_setCamera(self, camera)


    def getCamera(self):
        """getCamera(SoRenderManager self) -> SoCamera"""
        return _coin.SoRenderManager_getCamera(self)


    def setAutoClipping(self, autoclipping):
        """setAutoClipping(SoRenderManager self, SoRenderManager::AutoClippingStrategy autoclipping)"""
        return _coin.SoRenderManager_setAutoClipping(self, autoclipping)


    def attachRootSensor(self, sceneroot):
        """attachRootSensor(SoRenderManager self, SoNode sceneroot)"""
        return _coin.SoRenderManager_attachRootSensor(self, sceneroot)


    def attachClipSensor(self, sceneroot):
        """attachClipSensor(SoRenderManager self, SoNode sceneroot)"""
        return _coin.SoRenderManager_attachClipSensor(self, sceneroot)


    def detachRootSensor(self):
        """detachRootSensor(SoRenderManager self)"""
        return _coin.SoRenderManager_detachRootSensor(self)


    def detachClipSensor(self):
        """detachClipSensor(SoRenderManager self)"""
        return _coin.SoRenderManager_detachClipSensor(self)


    def getAutoClipping(self):
        """getAutoClipping(SoRenderManager self) -> SoRenderManager::AutoClippingStrategy"""
        return _coin.SoRenderManager_getAutoClipping(self)


    def setNearPlaneValue(self, value):
        """setNearPlaneValue(SoRenderManager self, float value)"""
        return _coin.SoRenderManager_setNearPlaneValue(self, value)


    def getNearPlaneValue(self):
        """getNearPlaneValue(SoRenderManager self) -> float"""
        return _coin.SoRenderManager_getNearPlaneValue(self)


    def setTexturesEnabled(self, onoff):
        """setTexturesEnabled(SoRenderManager self, SbBool const onoff)"""
        return _coin.SoRenderManager_setTexturesEnabled(self, onoff)


    def isTexturesEnabled(self):
        """isTexturesEnabled(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isTexturesEnabled(self)


    def setDoubleBuffer(self, enable):
        """setDoubleBuffer(SoRenderManager self, SbBool const enable)"""
        return _coin.SoRenderManager_setDoubleBuffer(self, enable)


    def isDoubleBuffer(self):
        """isDoubleBuffer(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isDoubleBuffer(self)


    def setRenderMode(self, mode):
        """setRenderMode(SoRenderManager self, SoRenderManager::RenderMode const mode)"""
        return _coin.SoRenderManager_setRenderMode(self, mode)


    def getRenderMode(self):
        """getRenderMode(SoRenderManager self) -> SoRenderManager::RenderMode"""
        return _coin.SoRenderManager_getRenderMode(self)


    def setStereoMode(self, mode):
        """setStereoMode(SoRenderManager self, SoRenderManager::StereoMode const mode)"""
        return _coin.SoRenderManager_setStereoMode(self, mode)


    def getStereoMode(self):
        """getStereoMode(SoRenderManager self) -> SoRenderManager::StereoMode"""
        return _coin.SoRenderManager_getStereoMode(self)


    def setStereoOffset(self, offset):
        """setStereoOffset(SoRenderManager self, float const offset)"""
        return _coin.SoRenderManager_setStereoOffset(self, offset)


    def getStereoOffset(self):
        """getStereoOffset(SoRenderManager self) -> float"""
        return _coin.SoRenderManager_getStereoOffset(self)


    def isAutoRedraw(self):
        """isAutoRedraw(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isAutoRedraw(self)


    def setRedrawPriority(self, priority):
        """setRedrawPriority(SoRenderManager self, uint32_t const priority)"""
        return _coin.SoRenderManager_setRedrawPriority(self, priority)


    def getRedrawPriority(self):
        """getRedrawPriority(SoRenderManager self) -> uint32_t"""
        return _coin.SoRenderManager_getRedrawPriority(self)


    def nodesensorCB(data, arg2):
        """nodesensorCB(void * data, SoSensor arg2)"""
        return _coin.SoRenderManager_nodesensorCB(data, arg2)

    nodesensorCB = staticmethod(nodesensorCB)

    def prerendercb(userdata, action):
        """prerendercb(void * userdata, SoGLRenderAction action)"""
        return _coin.SoRenderManager_prerendercb(userdata, action)

    prerendercb = staticmethod(prerendercb)

    def reinitialize(self):
        """reinitialize(SoRenderManager self)"""
        return _coin.SoRenderManager_reinitialize(self)


    def scheduleRedraw(self):
        """scheduleRedraw(SoRenderManager self)"""
        return _coin.SoRenderManager_scheduleRedraw(self)


    def setWindowSize(self, newsize):
        """setWindowSize(SoRenderManager self, SbVec2s newsize)"""
        return _coin.SoRenderManager_setWindowSize(self, newsize)


    def getWindowSize(self):
        """getWindowSize(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getWindowSize(self)


    def setSize(self, newsize):
        """setSize(SoRenderManager self, SbVec2s newsize)"""
        return _coin.SoRenderManager_setSize(self, newsize)


    def getSize(self):
        """getSize(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getSize(self)


    def setOrigin(self, newOrigin):
        """setOrigin(SoRenderManager self, SbVec2s newOrigin)"""
        return _coin.SoRenderManager_setOrigin(self, newOrigin)


    def getOrigin(self):
        """getOrigin(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getOrigin(self)


    def setViewportRegion(self, newRegion):
        """setViewportRegion(SoRenderManager self, SbViewportRegion newRegion)"""
        return _coin.SoRenderManager_setViewportRegion(self, newRegion)


    def getViewportRegion(self):
        """getViewportRegion(SoRenderManager self) -> SbViewportRegion"""
        return _coin.SoRenderManager_getViewportRegion(self)


    def setBackgroundColor(self, color):
        """setBackgroundColor(SoRenderManager self, SbColor4f color)"""
        return _coin.SoRenderManager_setBackgroundColor(self, color)


    def getBackgroundColor(self):
        """getBackgroundColor(SoRenderManager self) -> SbColor4f"""
        return _coin.SoRenderManager_getBackgroundColor(self)


    def setBackgroundIndex(self, index):
        """setBackgroundIndex(SoRenderManager self, int const index)"""
        return _coin.SoRenderManager_setBackgroundIndex(self, index)


    def getBackgroundIndex(self):
        """getBackgroundIndex(SoRenderManager self) -> int"""
        return _coin.SoRenderManager_getBackgroundIndex(self)


    def setRGBMode(self, onOrOff):
        """setRGBMode(SoRenderManager self, SbBool const onOrOff)"""
        return _coin.SoRenderManager_setRGBMode(self, onOrOff)


    def isRGBMode(self):
        """isRGBMode(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isRGBMode(self)


    def activate(self):
        """activate(SoRenderManager self)"""
        return _coin.SoRenderManager_activate(self)


    def deactivate(self):
        """deactivate(SoRenderManager self)"""
        return _coin.SoRenderManager_deactivate(self)


    def setAntialiasing(self, smoothing, numPasses):
        """setAntialiasing(SoRenderManager self, SbBool const smoothing, int const numPasses)"""
        return _coin.SoRenderManager_setAntialiasing(self, smoothing, numPasses)


    def getAntialiasing(self, smoothing, numPasses):
        """getAntialiasing(SoRenderManager self, SbBool & smoothing, int & numPasses)"""
        return _coin.SoRenderManager_getAntialiasing(self, smoothing, numPasses)


    def setGLRenderAction(self, action):
        """setGLRenderAction(SoRenderManager self, SoGLRenderAction action)"""
        return _coin.SoRenderManager_setGLRenderAction(self, action)


    def getGLRenderAction(self):
        """getGLRenderAction(SoRenderManager self) -> SoGLRenderAction"""
        return _coin.SoRenderManager_getGLRenderAction(self)


    def setAudioRenderAction(self, action):
        """setAudioRenderAction(SoRenderManager self, SoAudioRenderAction action)"""
        return _coin.SoRenderManager_setAudioRenderAction(self, action)


    def getAudioRenderAction(self):
        """getAudioRenderAction(SoRenderManager self) -> SoAudioRenderAction"""
        return _coin.SoRenderManager_getAudioRenderAction(self)


    def enableRealTimeUpdate(flag):
        """enableRealTimeUpdate(SbBool const flag)"""
        return _coin.SoRenderManager_enableRealTimeUpdate(flag)

    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(SoRenderManager self, SoRenderManagerRenderCB * f, void *const userData=None)
        setRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * f)
        setRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * userData=None)
        setRenderCallback(SoRenderManager self, PyObject * pyfunc)
        """
        return _coin.SoRenderManager_setRenderCallback(self, *args)


    def addPreRenderCallback(self, *args):
        """
        addPreRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        addPreRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_addPreRenderCallback(self, *args)


    def removePreRenderCallback(self, *args):
        """
        removePreRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        removePreRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_removePreRenderCallback(self, *args)


    def addPostRenderCallback(self, *args):
        """
        addPostRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        addPostRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_addPostRenderCallback(self, *args)


    def removePostRenderCallback(self, *args):
        """
        removePostRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        removePostRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_removePostRenderCallback(self, *args)

SoRenderManager_swigregister = _coin.SoRenderManager_swigregister
SoRenderManager_swigregister(SoRenderManager)

def SoRenderManager_nodesensorCB(data, arg3):
    """SoRenderManager_nodesensorCB(void * data, SoSensor arg3)"""
    return _coin.SoRenderManager_nodesensorCB(data, arg3)

def SoRenderManager_prerendercb(userdata, action):
    """SoRenderManager_prerendercb(void * userdata, SoGLRenderAction action)"""
    return _coin.SoRenderManager_prerendercb(userdata, action)

def SoRenderManager_enableRealTimeUpdate(flag):
    """SoRenderManager_enableRealTimeUpdate(SbBool const flag)"""
    return _coin.SoRenderManager_enableRealTimeUpdate(flag)

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(ScXMLObject 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, type):
        """isOfType(ScXMLObject self, SoType type) -> SbBool"""
        return _coin.ScXMLObject_isOfType(self, type)


    def setXMLAttribute(self, attribute, value):
        """setXMLAttribute(ScXMLObject self, char const * attribute, char const * value)"""
        return _coin.ScXMLObject_setXMLAttribute(self, attribute, value)


    def getXMLAttribute(self, attribute):
        """getXMLAttribute(ScXMLObject self, char const * attribute) -> char const *"""
        return _coin.ScXMLObject_getXMLAttribute(self, attribute)


    def handleXMLAttributes(self):
        """handleXMLAttributes(ScXMLObject self) -> SbBool"""
        return _coin.ScXMLObject_handleXMLAttributes(self)


    def setContainer(self, container):
        """setContainer(ScXMLObject self, ScXMLObject container)"""
        return _coin.ScXMLObject_setContainer(self, container)


    def getContainer(self):
        """getContainer(ScXMLObject self) -> ScXMLObject"""
        return _coin.ScXMLObject_getContainer(self)


    def isContainedIn(self, object):
        """isContainedIn(ScXMLObject self, ScXMLObject object) -> SbBool"""
        return _coin.ScXMLObject_isContainedIn(self, object)

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(ScXMLEvent 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__(ScXMLEvent 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, identifier):
        """setIdentifier(ScXMLEvent self, SbName identifier)"""
        return _coin.ScXMLEvent_setIdentifier(self, identifier)


    def getIdentifier(self):
        """getIdentifier(ScXMLEvent 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()


_coin.SCXML_DEFAULT_NS_swigconstant(_coin)
SCXML_DEFAULT_NS = _coin.SCXML_DEFAULT_NS

_coin.SCXML_COIN_NS_swigconstant(_coin)
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(filename):
        """readFile(char const * filename) -> ScXMLStateMachine"""
        return _coin.ScXML_readFile(filename)

    readFile = staticmethod(readFile)

    def readBuffer(bufferdata):
        """readBuffer(char const * bufferdata) -> ScXMLStateMachine"""
        return _coin.ScXML_readBuffer(bufferdata)

    readBuffer = staticmethod(readBuffer)

    def __init__(self):
        """__init__(ScXML 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(filename):
    """ScXML_readFile(char const * filename) -> ScXMLStateMachine"""
    return _coin.ScXML_readFile(filename)

def ScXML_readBuffer(bufferdata):
    """ScXML_readBuffer(char const * bufferdata) -> ScXMLStateMachine"""
    return _coin.ScXML_readBuffer(bufferdata)

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(ScXMLInvoke 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, id):
        """setTargetTypeAttribute(ScXMLInvoke self, char const * id)"""
        return _coin.ScXMLInvoke_setTargetTypeAttribute(self, id)


    def getTargetTypeAttribute(self):
        """getTargetTypeAttribute(ScXMLInvoke self) -> char const *"""
        return _coin.ScXMLInvoke_getTargetTypeAttribute(self)


    def setSrcAttribute(self, id):
        """setSrcAttribute(ScXMLInvoke self, char const * id)"""
        return _coin.ScXMLInvoke_setSrcAttribute(self, id)


    def getSrcAttribute(self):
        """getSrcAttribute(ScXMLInvoke self) -> char const *"""
        return _coin.ScXMLInvoke_getSrcAttribute(self)


    def setSrcExprAttribute(self, id):
        """setSrcExprAttribute(ScXMLInvoke self, char const * id)"""
        return _coin.ScXMLInvoke_setSrcExprAttribute(self, id)


    def getSrcExprAttribute(self):
        """getSrcExprAttribute(ScXMLInvoke self) -> char const *"""
        return _coin.ScXMLInvoke_getSrcExprAttribute(self)


    def handleXMLAttributes(self):
        """handleXMLAttributes(ScXMLInvoke self) -> SbBool"""
        return _coin.ScXMLInvoke_handleXMLAttributes(self)


    def invoke(self, statemachine):
        """invoke(ScXMLInvoke self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLInvoke_invoke(self, statemachine)

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(ScXMLStateMachine 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__(ScXMLStateMachine 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, name):
        """setName(ScXMLStateMachine self, SbName name)"""
        return _coin.ScXMLStateMachine_setName(self, name)


    def getName(self):
        """getName(ScXMLStateMachine self) -> SbName"""
        return _coin.ScXMLStateMachine_getName(self)


    def setDescription(self, document):
        """setDescription(ScXMLStateMachine self, ScXMLDocument * document)"""
        return _coin.ScXMLStateMachine_setDescription(self, document)


    def getDescription(self):
        """getDescription(ScXMLStateMachine self) -> ScXMLDocument const *"""
        return _coin.ScXMLStateMachine_getDescription(self)


    def initialize(self):
        """initialize(ScXMLStateMachine self)"""
        return _coin.ScXMLStateMachine_initialize(self)


    def queueEvent(self, *args):
        """
        queueEvent(ScXMLStateMachine self, ScXMLEvent event, SbBool dealloc=0)
        queueEvent(ScXMLStateMachine self, ScXMLEvent event)
        queueEvent(ScXMLStateMachine self, SbName eventid)
        """
        return _coin.ScXMLStateMachine_queueEvent(self, *args)


    def processEventQueue(self):
        """processEventQueue(ScXMLStateMachine self) -> SbBool"""
        return _coin.ScXMLStateMachine_processEventQueue(self)


    def isActive(self):
        """isActive(ScXMLStateMachine self) -> SbBool"""
        return _coin.ScXMLStateMachine_isActive(self)


    def isFinished(self):
        """isFinished(ScXMLStateMachine self) -> SbBool"""
        return _coin.ScXMLStateMachine_isFinished(self)


    def getCurrentEvent(self):
        """getCurrentEvent(ScXMLStateMachine self) -> ScXMLEvent"""
        return _coin.ScXMLStateMachine_getCurrentEvent(self)


    def getNumActiveStates(self):
        """getNumActiveStates(ScXMLStateMachine self) -> int"""
        return _coin.ScXMLStateMachine_getNumActiveStates(self)


    def getActiveState(self, idx):
        """getActiveState(ScXMLStateMachine self, int idx) -> ScXMLObject"""
        return _coin.ScXMLStateMachine_getActiveState(self, idx)


    def getState(self, identifier):
        """getState(ScXMLStateMachine self, char const * identifier) -> ScXMLObject"""
        return _coin.ScXMLStateMachine_getState(self, identifier)


    def addDeleteCallback(self, *args):
        """
        addDeleteCallback(ScXMLStateMachine self, ScXMLStateMachineDeleteCB * callback, void * userdata)
        addDeleteCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_addDeleteCallback(self, *args)


    def removeDeleteCallback(self, *args):
        """
        removeDeleteCallback(ScXMLStateMachine self, ScXMLStateMachineDeleteCB * callback, void * userdata)
        removeDeleteCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_removeDeleteCallback(self, *args)


    def addStateChangeCallback(self, *args):
        """
        addStateChangeCallback(ScXMLStateMachine self, ScXMLStateChangeCB * callback, void * userdata)
        addStateChangeCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_addStateChangeCallback(self, *args)


    def removeStateChangeCallback(self, *args):
        """
        removeStateChangeCallback(ScXMLStateMachine self, ScXMLStateChangeCB * callback, void * userdata)
        removeStateChangeCallback(ScXMLStateMachine 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(SoScXMLEvent 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__(SoScXMLEvent 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, soevent):
        """setSoEvent(SoScXMLEvent self, SoEvent soevent)"""
        return _coin.SoScXMLEvent_setSoEvent(self, soevent)


    def getSoEvent(self):
        """getSoEvent(SoScXMLEvent self) -> SoEvent"""
        return _coin.SoScXMLEvent_getSoEvent(self)


    def setUpIdentifier(self):
        """setUpIdentifier(SoScXMLEvent 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(SoScXMLStateMachine 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__(SoScXMLStateMachine 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, root):
        """setSceneGraphRoot(SoScXMLStateMachine self, SoNode root)"""
        return _coin.SoScXMLStateMachine_setSceneGraphRoot(self, root)


    def getSceneGraphRoot(self):
        """getSceneGraphRoot(SoScXMLStateMachine self) -> SoNode"""
        return _coin.SoScXMLStateMachine_getSceneGraphRoot(self)


    def setActiveCamera(self, camera):
        """setActiveCamera(SoScXMLStateMachine self, SoCamera camera)"""
        return _coin.SoScXMLStateMachine_setActiveCamera(self, camera)


    def getActiveCamera(self):
        """getActiveCamera(SoScXMLStateMachine self) -> SoCamera"""
        return _coin.SoScXMLStateMachine_getActiveCamera(self)


    def setViewportRegion(self, vp):
        """setViewportRegion(SoScXMLStateMachine self, SbViewportRegion vp)"""
        return _coin.SoScXMLStateMachine_setViewportRegion(self, vp)


    def getViewportRegion(self):
        """getViewportRegion(SoScXMLStateMachine self) -> SbViewportRegion"""
        return _coin.SoScXMLStateMachine_getViewportRegion(self)


    def preGLRender(self):
        """preGLRender(SoScXMLStateMachine self)"""
        return _coin.SoScXMLStateMachine_preGLRender(self)


    def postGLRender(self):
        """postGLRender(SoScXMLStateMachine self)"""
        return _coin.SoScXMLStateMachine_postGLRender(self)


    def processSoEvent(self, event):
        """processSoEvent(SoScXMLStateMachine self, SoEvent event) -> SbBool"""
        return _coin.SoScXMLStateMachine_processSoEvent(self, event)

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)



