# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# 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 as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _coin
else:
    import _coin

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class charp(object):
    r"""Proxy of C++ charp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(charp self) -> charp"""
        _coin.charp_swiginit(self, _coin.new_charp())
    __swig_destroy__ = _coin.delete_charp

    def assign(self, value):
        r"""assign(charp self, char value)"""
        return _coin.charp_assign(self, value)

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

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

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

# Register charp in _coin:
_coin.charp_swigregister(charp)
cast = _coin.cast

class intp(object):
    r"""Proxy of C++ intp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(intp self) -> intp"""
        _coin.intp_swiginit(self, _coin.new_intp())
    __swig_destroy__ = _coin.delete_intp

    def assign(self, value):
        r"""assign(intp self, int value)"""
        return _coin.intp_assign(self, value)

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

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

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

# Register intp in _coin:
_coin.intp_swigregister(intp)
class longp(object):
    r"""Proxy of C++ longp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(longp self) -> longp"""
        _coin.longp_swiginit(self, _coin.new_longp())
    __swig_destroy__ = _coin.delete_longp

    def assign(self, value):
        r"""assign(longp self, long value)"""
        return _coin.longp_assign(self, value)

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

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

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

# Register longp in _coin:
_coin.longp_swigregister(longp)
class floatp(object):
    r"""Proxy of C++ floatp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(floatp self) -> floatp"""
        _coin.floatp_swiginit(self, _coin.new_floatp())
    __swig_destroy__ = _coin.delete_floatp

    def assign(self, value):
        r"""assign(floatp self, float value)"""
        return _coin.floatp_assign(self, value)

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

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

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

# Register floatp in _coin:
_coin.floatp_swigregister(floatp)
class doublep(object):
    r"""Proxy of C++ doublep class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(doublep self) -> doublep"""
        _coin.doublep_swiginit(self, _coin.new_doublep())
    __swig_destroy__ = _coin.delete_doublep

    def assign(self, value):
        r"""assign(doublep self, double value)"""
        return _coin.doublep_assign(self, value)

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

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

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

# Register doublep in _coin:
_coin.doublep_swigregister(doublep)
FALSE = _coin.FALSE

TRUE = _coin.TRUE

HAVE_INTTYPES_H = _coin.HAVE_INTTYPES_H

HAVE_STDINT_H = _coin.HAVE_STDINT_H

HAVE_SYS_TYPES_H = _coin.HAVE_SYS_TYPES_H

HAVE_STDDEF_H = _coin.HAVE_STDDEF_H

HAVE_INT8_T = _coin.HAVE_INT8_T

HAVE_UINT8_T = _coin.HAVE_UINT8_T

HAVE_INT16_T = _coin.HAVE_INT16_T

HAVE_UINT16_T = _coin.HAVE_UINT16_T

HAVE_INT32_T = _coin.HAVE_INT32_T

HAVE_UINT32_T = _coin.HAVE_UINT32_T

HAVE_INT64_T = _coin.HAVE_INT64_T

HAVE_UINT64_T = _coin.HAVE_UINT64_T

HAVE_INTPTR_T = _coin.HAVE_INTPTR_T

HAVE_UINTPTR_T = _coin.HAVE_UINTPTR_T

M_E = _coin.M_E

M_LOG2E = _coin.M_LOG2E

M_LOG10E = _coin.M_LOG10E

M_LN2 = _coin.M_LN2

M_LN10 = _coin.M_LN10

M_PI = _coin.M_PI

M_TWOPI = _coin.M_TWOPI

M_PI_2 = _coin.M_PI_2

M_PI_4 = _coin.M_PI_4

M_3PI_4 = _coin.M_3PI_4

M_SQRTPI = _coin.M_SQRTPI

M_1_PI = _coin.M_1_PI

M_2_PI = _coin.M_2_PI

M_2_SQRTPI = _coin.M_2_SQRTPI

M_SQRT2 = _coin.M_SQRT2

M_SQRT1_2 = _coin.M_SQRT1_2

M_LN2LO = _coin.M_LN2LO

M_LN2HI = _coin.M_LN2HI

M_SQRT3 = _coin.M_SQRT3

M_IVLN10 = _coin.M_IVLN10

M_LOG2_E = _coin.M_LOG2_E

M_INVLN2 = _coin.M_INVLN2

COIN_MAJOR_VERSION = _coin.COIN_MAJOR_VERSION

COIN_MINOR_VERSION = _coin.COIN_MINOR_VERSION

COIN_MICRO_VERSION = _coin.COIN_MICRO_VERSION

COIN_VERSION = _coin.COIN_VERSION

HAVE_HASH_QUOTING = _coin.HAVE_HASH_QUOTING

SUN_CC_4_0_SOTYPE_INIT_BUG = _coin.SUN_CC_4_0_SOTYPE_INIT_BUG

class SbDict(object):
    r"""Proxy of C++ SbDict class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbDict self, int const entries=251) -> SbDict
        __init__(SbDict self, SbDict srcFrom) -> SbDict
        """
        _coin.SbDict_swiginit(self, _coin.new_SbDict(*args))
    __swig_destroy__ = _coin.delete_SbDict

    def applyToAll(self, *args):
        r"""
        applyToAll(SbDict self, SbDictApplyFunc * rtn)
        applyToAll(SbDict self, SbDictApplyDataFunc * rtn, void * data)
        """
        return _coin.SbDict_applyToAll(self, *args)

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

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

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

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

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

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

# Register SbDict in _coin:
_coin.SbDict_swigregister(SbDict)
class SoType(object):
    r"""Proxy of C++ SoType class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def fromName(name):
        r"""fromName(SbName name) -> SoType"""
        return _coin.SoType_fromName(name)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @staticmethod
    def init():
        r"""init()"""
        return _coin.SoType_init()

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

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

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

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

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

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

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

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

    def __init__(self):
        r"""__init__(SoType self) -> SoType"""
        _coin.SoType_swiginit(self, _coin.new_SoType())
    __swig_destroy__ = _coin.delete_SoType

# Register SoType in _coin:
_coin.SoType_swigregister(SoType)
class SbPList(object):
    r"""Proxy of C++ SbPList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbPList self, int const sizehint=) -> SbPList
        __init__(SbPList self, SbPList l) -> SbPList
        """
        _coin.SbPList_swiginit(self, _coin.new_SbPList(*args))
    __swig_destroy__ = _coin.delete_SbPList

    def copy(self, l):
        r"""copy(SbPList self, SbPList l)"""
        return _coin.SbPList_copy(self, l)

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

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

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

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

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

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

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

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

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

    def getArrayPtr(self, start=0):
        r"""getArrayPtr(SbPList self, int const start=0)"""
        return _coin.SbPList_getArrayPtr(self, start)

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

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

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

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

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

    def __setitem__(self, i, val):
        r"""__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]


# Register SbPList in _coin:
_coin.SbPList_swigregister(SbPList)
class SbIntList(SbPList):
    r"""Proxy of C++ SbIntList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbIntList self) -> SbIntList
        __init__(SbIntList self, int const sizehint) -> SbIntList
        """
        _coin.SbIntList_swiginit(self, _coin.new_SbIntList(*args))

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

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

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

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

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

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

# Register SbIntList in _coin:
_coin.SbIntList_swigregister(SbIntList)
class SbString(object):
    r"""Proxy of C++ SbString class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbString_swiginit(self, _coin.new_SbString(*args))
    __swig_destroy__ = _coin.delete_SbString

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

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

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

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

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

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

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

    def __iadd__(self, *args):
        r"""
        __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):
        r"""compareSubString(SbString self, char const * text, int offset=0) -> int"""
        return _coin.SbString_compareSubString(self, text, offset)

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

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

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

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

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

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

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

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

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

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


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

# Register SbString in _coin:
_coin.SbString_swigregister(SbString)
class SbName(object):
    r"""Proxy of C++ SbName class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SbName self) -> SbName
        __init__(SbName self, char const * namestring) -> SbName
        __init__(SbName self, SbString str) -> SbName
        __init__(SbName self, SbName name) -> SbName
        """
        _coin.SbName_swiginit(self, _coin.new_SbName(*args))
    __swig_destroy__ = _coin.delete_SbName

    def getString(self):
        r"""getString(SbName self) -> char const *"""
        return _coin.SbName_getString(self)

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

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

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

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

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

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

    def __eq__(self, *args):
        r"""
        __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):
        r"""
        __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):
        r"""__getitem__(SbName self, int i) -> char"""
        return _coin.SbName___getitem__(self, i)

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


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

# Register SbName in _coin:
_coin.SbName_swigregister(SbName)
class SoError(object):
    r"""Proxy of C++ SoError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoError self) -> SoError"""
        _coin.SoError_swiginit(self, _coin.new_SoError())
    __swig_destroy__ = _coin.delete_SoError

    @staticmethod
    def setHandlerCallback(func, data):
        r"""setHandlerCallback(SoErrorCB *const func, void *const data)"""
        return _coin.SoError_setHandlerCallback(func, data)

    @staticmethod
    def getHandlerCallback():
        r"""getHandlerCallback() -> SoErrorCB *"""
        return _coin.SoError_getHandlerCallback()

    @staticmethod
    def getHandlerData():
        r"""getHandlerData() -> void *"""
        return _coin.SoError_getHandlerData()

    def getDebugString(self):
        r"""getDebugString(SoError self) -> SbString"""
        return _coin.SoError_getDebugString(self)

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

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

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

    @staticmethod
    def post(*args):
        r"""post(char const *const format)"""
        return _coin.SoError_post(*args)

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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoError_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoError_initClasses()

# Register SoError in _coin:
_coin.SoError_swigregister(SoError)
class SoDebugError(SoError):
    r"""Proxy of C++ SoDebugError class."""

    thisown = 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
    

    @staticmethod
    def setHandlerCallback(function, data):
        r"""setHandlerCallback(SoErrorCB *const function, void *const data)"""
        return _coin.SoDebugError_setHandlerCallback(function, data)

    @staticmethod
    def getHandlerCallback():
        r"""getHandlerCallback() -> SoErrorCB *"""
        return _coin.SoDebugError_getHandlerCallback()

    @staticmethod
    def getHandlerData():
        r"""getHandlerData() -> void *"""
        return _coin.SoDebugError_getHandlerData()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDebugError_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDebugError self) -> SoType"""
        return _coin.SoDebugError_getTypeId(self)

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

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

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

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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDebugError_initClass()

    def __init__(self):
        r"""__init__(SoDebugError self) -> SoDebugError"""
        _coin.SoDebugError_swiginit(self, _coin.new_SoDebugError())
    __swig_destroy__ = _coin.delete_SoDebugError

# Register SoDebugError in _coin:
_coin.SoDebugError_swigregister(SoDebugError)
class SbVec2s(object):
    r"""Proxy of C++ SbVec2s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec2s_swiginit(self, _coin.new_SbVec2s(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""getValue(SbVec2s self)"""
        return _coin.SbVec2s_getValue(self)

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

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

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

    def __itruediv__(self, *args):
        return _coin.SbVec2s___itruediv__(self, *args)
    __idiv__ = __itruediv__



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

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

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

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

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

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

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

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

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

    def __truediv__(self, d):
        r"""__truediv__(SbVec2s self, double const d) -> SbVec2s"""
        return _coin.SbVec2s___truediv__(self, d)

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

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

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

    def __setitem__(self, i, value):
        r"""__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

# Register SbVec2s in _coin:
_coin.SbVec2s_swigregister(SbVec2s)
class SbTime(object):
    r"""Proxy of C++ SbTime class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbTime_swiginit(self, _coin.new_SbTime(*args))

    @staticmethod
    def getTimeOfDay():
        r"""getTimeOfDay() -> SbTime"""
        return _coin.SbTime_getTimeOfDay()

    def setToTimeOfDay(self):
        r"""setToTimeOfDay(SbTime self)"""
        return _coin.SbTime_setToTimeOfDay(self)

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

    @staticmethod
    def max():
        r"""max() -> SbTime"""
        return _coin.SbTime_max()

    @staticmethod
    def maxTime():
        r"""maxTime() -> SbTime"""
        return _coin.SbTime_maxTime()

    @staticmethod
    def sleep(msec):
        r"""sleep(int msec)"""
        return _coin.SbTime_sleep(msec)

    def setValue(self, *args):
        r"""
        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):
        r"""setMsecValue(SbTime self, unsigned long const msec)"""
        return _coin.SbTime_setMsecValue(self, msec)

    def getValue(self, *args):
        r"""
        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):
        r"""getMsecValue(SbTime self) -> unsigned long"""
        return _coin.SbTime_getMsecValue(self)

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

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

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

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

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

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

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

    def __itruediv__(self, *args):
        return _coin.SbTime___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __truediv__(self, *args):
        return _coin.SbTime___truediv__(self, *args)
    __div__ = __truediv__



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

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

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

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

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

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

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

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

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

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

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

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

    def __div__(self, d):
        r"""__div__(SbTime self, double const d) -> SbTime"""
        return _coin.SbTime___div__(self, d)
    __swig_destroy__ = _coin.delete_SbTime

# Register SbTime in _coin:
_coin.SbTime_swigregister(SbTime)
class SoEvent(object):
    r"""Proxy of C++ SoEvent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoEvent self) -> SoEvent"""
        _coin.SoEvent_swiginit(self, _coin.new_SoEvent())
    __swig_destroy__ = _coin.delete_SoEvent

    def isOfType(self, type):
        r"""isOfType(SoEvent self, SoType type) -> SbBool"""
        return _coin.SoEvent_isOfType(self, type)

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

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

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

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

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

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

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

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

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

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

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

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

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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoEvent_initClass()

# Register SoEvent in _coin:
_coin.SoEvent_swigregister(SoEvent)
class SoNotRec(object):
    r"""Proxy of C++ SoNotRec class."""

    thisown = 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):
        r"""__init__(SoNotRec self, SoBase notifbase) -> SoNotRec"""
        _coin.SoNotRec_swiginit(self, _coin.new_SoNotRec(notifbase))

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

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

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

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

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

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

# Register SoNotRec in _coin:
_coin.SoNotRec_swigregister(SoNotRec)
class SoNotList(object):
    r"""Proxy of C++ SoNotList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoNotList self) -> SoNotList
        __init__(SoNotList self, SoNotList nl) -> SoNotList
        """
        _coin.SoNotList_swiginit(self, _coin.new_SoNotList(*args))

    def append(self, *args):
        r"""
        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):
        r"""setLastType(SoNotList self, SoNotRec::Type const type)"""
        return _coin.SoNotList_setLastType(self, type)

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

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

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

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

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

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

    def output(self, *args):
        r"""output(SoNotList self, FILE *const file=stdout)"""
        return _coin.SoNotList_output(self, *args)
    __swig_destroy__ = _coin.delete_SoNotList

# Register SoNotList in _coin:
_coin.SoNotList_swigregister(SoNotList)
class SoField(object):
    r"""Proxy of C++ SoField class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoField_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoField_initClasses()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoField_cleanupClass()

    def setIgnored(self, ignore):
        r"""setIgnored(SoField self, SbBool ignore)"""
        return _coin.SoField_setIgnored(self, ignore)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    def values(self):
      def _values(obj):
        for value in obj:
          if hasattr(value, "__iter__"):
            yield list(_values(value))
          else:
            yield value
      out = _values(self)
      return list(out)

    @values.setter
    def values(self, arr):
      self.deleteValues(0)
      self.setValues(0, len(arr), arr)



# Register SoField in _coin:
_coin.SoField_swigregister(SoField)
class SoSField(SoField):
    r"""Proxy of C++ SoSField class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSField_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSField_getClassTypeId()

    @staticmethod
    def atexit_cleanup():
        r"""atexit_cleanup()"""
        return _coin.SoSField_atexit_cleanup()

# Register SoSField in _coin:
_coin.SoSField_swigregister(SoSField)
class SoMField(SoField):
    r"""Proxy of C++ SoMField class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMField_getClassTypeId()

    @staticmethod
    def atexit_cleanup():
        r"""atexit_cleanup()"""
        return _coin.SoMField_atexit_cleanup()

    def getNum(self):
        r"""getNum(SoMField self) -> int"""
        return _coin.SoMField_getNum(self)

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

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

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

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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMField_initClass()

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

    def isDeleteValuesEnabled(self):
        r"""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):
        r"""__len__(SoMField self) -> int"""
        return _coin.SoMField___len__(self)

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

# Register SoMField in _coin:
_coin.SoMField_swigregister(SoMField)
class SoAuditorList(object):
    r"""Proxy of C++ SoAuditorList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoAuditorList self) -> SoAuditorList"""
        _coin.SoAuditorList_swiginit(self, _coin.new_SoAuditorList())
    __swig_destroy__ = _coin.delete_SoAuditorList

    def append(self, auditor, type):
        r"""append(SoAuditorList self, void *const auditor, SoNotRec::Type const type)"""
        return _coin.SoAuditorList_append(self, auditor, type)

    def set(self, index, auditor, type):
        r"""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):
        r"""getObject(SoAuditorList self, int const index) -> void *"""
        return _coin.SoAuditorList_getObject(self, index)

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

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

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

    def remove(self, *args):
        r"""
        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):
        r"""notify(SoAuditorList self, SoNotList l)"""
        return _coin.SoAuditorList_notify(self, l)

# Register SoAuditorList in _coin:
_coin.SoAuditorList_swigregister(SoAuditorList)
class SoBase(object):
    r"""Proxy of C++ SoBase class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBase_initClass()

    def ref(self):
        r"""ref(SoBase self)"""
        return _coin.SoBase_ref(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @staticmethod
    def incrementCurrentWriteCounter():
        r"""incrementCurrentWriteCounter()"""
        return _coin.SoBase_incrementCurrentWriteCounter()

    @staticmethod
    def decrementCurrentWriteCounter():
        r"""decrementCurrentWriteCounter()"""
        return _coin.SoBase_decrementCurrentWriteCounter()

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

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

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

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

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

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

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

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

    @staticmethod
    def readRoute(input):
        r"""readRoute(SoInput input) -> SbBool"""
        return _coin.SoBase_readRoute(input)
    __swig_destroy__ = _coin.delete_SoBase

    def __hash__(self):
        r"""__hash__(SoBase self) -> size_t"""
        return _coin.SoBase___hash__(self)

    def __eq__(self,other):
      return (self.this == other.this) if other is not None else False
    def __ne__(self,other):
      return (self.this != other.this) if other is not None else True
    def __nonzero__(self):
      return True


# Register SoBase in _coin:
_coin.SoBase_swigregister(SoBase)

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

def intrusive_ptr_release(obj):
    r"""intrusive_ptr_release(SoBase obj)"""
    return _coin.intrusive_ptr_release(obj)
class SoBaseList(SbPList):
    r"""Proxy of C++ SoBaseList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoBaseList self) -> SoBaseList
        __init__(SoBaseList self, int const size) -> SoBaseList
        __init__(SoBaseList self, SoBaseList l) -> SoBaseList
        """
        _coin.SoBaseList_swiginit(self, _coin.new_SoBaseList(*args))
    __swig_destroy__ = _coin.delete_SoBaseList

    def append(self, ptr):
        r"""append(SoBaseList self, SoBase ptr)"""
        return _coin.SoBaseList_append(self, ptr)

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

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

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

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

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

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

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

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

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

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

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

# Register SoBaseList in _coin:
_coin.SoBaseList_swigregister(SoBaseList)
class SoNodeList(SoBaseList):
    r"""Proxy of C++ SoNodeList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoNodeList self) -> SoNodeList
        __init__(SoNodeList self, int const size) -> SoNodeList
        __init__(SoNodeList self, SoNodeList nl) -> SoNodeList
        """
        _coin.SoNodeList_swiginit(self, _coin.new_SoNodeList(*args))
    __swig_destroy__ = _coin.delete_SoNodeList

    def append(self, ptr):
        r"""append(SoNodeList self, SoNode ptr)"""
        return _coin.SoNodeList_append(self, ptr)

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

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

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

# Register SoNodeList in _coin:
_coin.SoNodeList_swigregister(SoNodeList)
class SoDetailList(SbPList):
    r"""Proxy of C++ SoDetailList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoDetailList self) -> SoDetailList
        __init__(SoDetailList self, int const sizehint) -> SoDetailList
        __init__(SoDetailList self, SoDetailList l) -> SoDetailList
        """
        _coin.SoDetailList_swiginit(self, _coin.new_SoDetailList(*args))
    __swig_destroy__ = _coin.delete_SoDetailList

    def append(self, detail):
        r"""append(SoDetailList self, SoDetail detail)"""
        return _coin.SoDetailList_append(self, detail)

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

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

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

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

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

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

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

# Register SoDetailList in _coin:
_coin.SoDetailList_swigregister(SoDetailList)
class SoTypeList(SbPList):
    r"""Proxy of C++ SoTypeList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoTypeList self) -> SoTypeList
        __init__(SoTypeList self, int const sizehint) -> SoTypeList
        __init__(SoTypeList self, SoTypeList l) -> SoTypeList
        """
        _coin.SoTypeList_swiginit(self, _coin.new_SoTypeList(*args))

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

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

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

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

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

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

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

# Register SoTypeList in _coin:
_coin.SoTypeList_swigregister(SoTypeList)
class SoEnabledElementsList(object):
    r"""Proxy of C++ SoEnabledElementsList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, parentlist):
        r"""__init__(SoEnabledElementsList self, SoEnabledElementsList parentlist) -> SoEnabledElementsList"""
        _coin.SoEnabledElementsList_swiginit(self, _coin.new_SoEnabledElementsList(parentlist))
    __swig_destroy__ = _coin.delete_SoEnabledElementsList

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

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

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

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

# Register SoEnabledElementsList in _coin:
_coin.SoEnabledElementsList_swigregister(SoEnabledElementsList)
class SoEngineOutputList(SbPList):
    r"""Proxy of C++ SoEngineOutputList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoEngineOutputList self) -> SoEngineOutputList
        __init__(SoEngineOutputList self, int const sizehint) -> SoEngineOutputList
        __init__(SoEngineOutputList self, SoEngineOutputList l) -> SoEngineOutputList
        """
        _coin.SoEngineOutputList_swiginit(self, _coin.new_SoEngineOutputList(*args))

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

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

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

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

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

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

# Register SoEngineOutputList in _coin:
_coin.SoEngineOutputList_swigregister(SoEngineOutputList)
class SoEngineList(SoBaseList):
    r"""Proxy of C++ SoEngineList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoEngineList self) -> SoEngineList
        __init__(SoEngineList self, int const size) -> SoEngineList
        __init__(SoEngineList self, SoEngineList el) -> SoEngineList
        """
        _coin.SoEngineList_swiginit(self, _coin.new_SoEngineList(*args))
    __swig_destroy__ = _coin.delete_SoEngineList

    def append(self, ptr):
        r"""append(SoEngineList self, SoEngine ptr)"""
        return _coin.SoEngineList_append(self, ptr)

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

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

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

# Register SoEngineList in _coin:
_coin.SoEngineList_swigregister(SoEngineList)
class SoFieldList(SbPList):
    r"""Proxy of C++ SoFieldList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoFieldList self) -> SoFieldList
        __init__(SoFieldList self, int const sizehint) -> SoFieldList
        __init__(SoFieldList self, SoFieldList l) -> SoFieldList
        """
        _coin.SoFieldList_swiginit(self, _coin.new_SoFieldList(*args))

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

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

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

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

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

    def get(self, *args):
        r"""
        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

# Register SoFieldList in _coin:
_coin.SoFieldList_swigregister(SoFieldList)
class SoPathList(SoBaseList):
    r"""Proxy of C++ SoPathList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoPathList self) -> SoPathList
        __init__(SoPathList self, int const size) -> SoPathList
        __init__(SoPathList self, SoPathList pl) -> SoPathList
        """
        _coin.SoPathList_swiginit(self, _coin.new_SoPathList(*args))
    __swig_destroy__ = _coin.delete_SoPathList

    def append(self, path):
        r"""append(SoPathList self, SoPath path)"""
        return _coin.SoPathList_append(self, path)

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

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

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

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

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

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

# Register SoPathList in _coin:
_coin.SoPathList_swigregister(SoPathList)
class SoPickedPointList(SbPList):
    r"""Proxy of C++ SoPickedPointList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoPickedPointList self) -> SoPickedPointList
        __init__(SoPickedPointList self, int const sizehint) -> SoPickedPointList
        __init__(SoPickedPointList self, SoPickedPointList l) -> SoPickedPointList
        """
        _coin.SoPickedPointList_swiginit(self, _coin.new_SoPickedPointList(*args))
    __swig_destroy__ = _coin.delete_SoPickedPointList

    def append(self, pp):
        r"""append(SoPickedPointList self, SoPickedPoint pp)"""
        return _coin.SoPickedPointList_append(self, pp)

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

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

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

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

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

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

# Register SoPickedPointList in _coin:
_coin.SoPickedPointList_swigregister(SoPickedPointList)
class SoPath(SoBase):
    r"""Proxy of C++ SoPath class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPath_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoPath self, int const approxlength=4) -> SoPath
        __init__(SoPath self, SoNode head) -> SoPath
        __init__(SoPath self, SoPath rhs) -> SoPath
        """
        _coin.SoPath_swiginit(self, _coin.new_SoPath(*args))

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPath_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPath self) -> SoType"""
        return _coin.SoPath_getTypeId(self)

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

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

    def append(self, *args):
        r"""
        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):
        r"""push(SoPath self, int const childindex)"""
        return _coin.SoPath_push(self, childindex)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def insertIndex(self, parent, newindex):
        r"""insertIndex(SoPath self, SoNode parent, int const newindex)"""
        return _coin.SoPath_insertIndex(self, parent, newindex)

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

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

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

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

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

# Register SoPath in _coin:
_coin.SoPath_swigregister(SoPath)
class SoLightPath(object):
    r"""Proxy of C++ SoLightPath class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoLightPath self, SoNode node, int const approxlength) -> SoLightPath
        __init__(SoLightPath self, int const approxlength) -> SoLightPath
        """
        _coin.SoLightPath_swiginit(self, _coin.new_SoLightPath(*args))
    __swig_destroy__ = _coin.delete_SoLightPath

    def setHead(self, node):
        r"""setHead(SoLightPath self, SoNode node)"""
        return _coin.SoLightPath_setHead(self, node)

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

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

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

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

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

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

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

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

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

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

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

# Register SoLightPath in _coin:
_coin.SoLightPath_swigregister(SoLightPath)
class SoFullPath(SoPath):
    r"""Proxy of C++ SoFullPath class."""

    thisown = property(lambda x: x.this.own(), lambda 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):
        r"""pop(SoFullPath self)"""
        return _coin.SoFullPath_pop(self)

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

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

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

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

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

# Register SoFullPath in _coin:
_coin.SoFullPath_swigregister(SoFullPath)
class SoTempPath(SoFullPath):
    r"""Proxy of C++ SoTempPath class."""

    thisown = property(lambda x: x.this.own(), lambda 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):
        r"""simpleAppend(SoTempPath self, SoNode node, int const index)"""
        return _coin.SoTempPath_simpleAppend(self, node, index)

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

# Register SoTempPath in _coin:
_coin.SoTempPath_swigregister(SoTempPath)
class SoActionMethodList(SbPList):
    r"""Proxy of C++ SoActionMethodList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, parentlist):
        r"""__init__(SoActionMethodList self, SoActionMethodList parentlist) -> SoActionMethodList"""
        _coin.SoActionMethodList_swiginit(self, _coin.new_SoActionMethodList(parentlist))
    __swig_destroy__ = _coin.delete_SoActionMethodList

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

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

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

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

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

# Register SoActionMethodList in _coin:
_coin.SoActionMethodList_swigregister(SoActionMethodList)
class SoAction(object):
    r"""Proxy of C++ SoAction class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAction_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoAction_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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAction_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoAction self) -> SoType"""
        return _coin.SoAction_getTypeId(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SoAction in _coin:
_coin.SoAction_swigregister(SoAction)
class SoState(object):
    r"""Proxy of C++ SoState class."""

    thisown = 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):
        r"""__init__(SoState self, SoAction action, SoTypeList enabledelements) -> SoState"""
        _coin.SoState_swiginit(self, _coin.new_SoState(action, enabledelements))
    __swig_destroy__ = _coin.delete_SoState

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

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

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

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

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

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

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

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

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

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

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

# Register SoState in _coin:
_coin.SoState_swigregister(SoState)
class SoElement(object):
    r"""Proxy of C++ SoElement class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoElement_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoElement_getClassStackIndex()

    def getTypeId(self):
        r"""getTypeId(SoElement self) -> SoType"""
        return _coin.SoElement_getTypeId(self)

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

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

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

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

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

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

    @staticmethod
    def initElements():
        r"""initElements()"""
        return _coin.SoElement_initElements()

    @staticmethod
    def getNumStackIndices():
        r"""getNumStackIndices() -> int"""
        return _coin.SoElement_getNumStackIndices()

    @staticmethod
    def getIdFromStackIndex(stackIndex):
        r"""getIdFromStackIndex(int const stackIndex) -> SoType"""
        return _coin.SoElement_getIdFromStackIndex(stackIndex)

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

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

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

# Register SoElement in _coin:
_coin.SoElement_swigregister(SoElement)
class SoInt32Element(SoElement):
    r"""Proxy of C++ SoInt32Element class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInt32Element_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoInt32Element_getClassStackIndex()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInt32Element_initClass()

    def init(self, state):
        r"""init(SoInt32Element self, SoState state)"""
        return _coin.SoInt32Element_init(self, state)

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

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

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

    @staticmethod
    def set(*args):
        r"""
        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)

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

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

# Register SoInt32Element in _coin:
_coin.SoInt32Element_swigregister(SoInt32Element)
class SoDecimationTypeElement(SoInt32Element):
    r"""Proxy of C++ SoDecimationTypeElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecimationTypeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoDecimationTypeElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDecimationTypeElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDecimationTypeElement_initClass()
    AUTOMATIC = _coin.SoDecimationTypeElement_AUTOMATIC
    
    HIGHEST = _coin.SoDecimationTypeElement_HIGHEST
    
    LOWEST = _coin.SoDecimationTypeElement_LOWEST
    
    PERCENTAGE = _coin.SoDecimationTypeElement_PERCENTAGE
    

    def init(self, state):
        r"""init(SoDecimationTypeElement self, SoState state)"""
        return _coin.SoDecimationTypeElement_init(self, state)

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

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

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoDecimationTypeElement::Type"""
        return _coin.SoDecimationTypeElement_getDefault()

# Register SoDecimationTypeElement in _coin:
_coin.SoDecimationTypeElement_swigregister(SoDecimationTypeElement)
class SoFieldData(object):
    r"""Proxy of C++ SoFieldData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoFieldData self) -> SoFieldData
        __init__(SoFieldData self, SoFieldData fd) -> SoFieldData
        __init__(SoFieldData self, SoFieldData fd) -> SoFieldData
        __init__(SoFieldData self, int numfields) -> SoFieldData
        """
        _coin.SoFieldData_swiginit(self, _coin.new_SoFieldData(*args))
    __swig_destroy__ = _coin.delete_SoFieldData

    def addField(self, base, name, field):
        r"""addField(SoFieldData self, SoFieldContainer base, char const * name, SoField field)"""
        return _coin.SoFieldData_addField(self, base, name, field)

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

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

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

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

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

    def addEnumValue(self, enumname, valuename, value):
        r"""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):
        r"""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):
        r"""
        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):
        r"""write(SoFieldData self, SoOutput out, SoFieldContainer object)"""
        return _coin.SoFieldData_write(self, out, object)

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

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

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

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

# Register SoFieldData in _coin:
_coin.SoFieldData_swigregister(SoFieldData)
class SoFieldContainer(SoBase):
    r"""Proxy of C++ SoFieldContainer class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFieldContainer_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFieldContainer_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoFieldContainer_cleanupClass()

    def setToDefaults(self):
        r"""setToDefaults(SoFieldContainer self)"""
        return _coin.SoFieldContainer_setToDefaults(self)

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

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

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

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

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

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

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

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

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

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

    def set(self, *args):
        r"""
        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):
        r"""
        get(SoFieldContainer self, SbString fielddata)
        get(SoFieldContainer self, SbString fielddata, SoOutput out)
        """
        return _coin.SoFieldContainer_get(self, *args)

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

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

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

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

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

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

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

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

    @staticmethod
    def initCopyDict():
        r"""initCopyDict()"""
        return _coin.SoFieldContainer_initCopyDict()

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

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

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

    @staticmethod
    def copyDone():
        r"""copyDone()"""
        return _coin.SoFieldContainer_copyDone()

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

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

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

    def getFieldName(self, *args):
        r"""
        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 as e:
    ##############################################################
            if name == "this":
                raise AttributeError
    ##############################################################
            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

    @property
    def values(self):
        def _values(obj):
            for value in obj:
                if hasattr(value, "__iter__"):
                    yield list(_values(value))
                else:
                    yield value
        out = _values(self)
        return list(out)

    @values.setter
    def values(self, arr):
        self.deleteValues(0)
        self.setValues(0, len(arr), arr)



# Register SoFieldContainer in _coin:
_coin.SoFieldContainer_swigregister(SoFieldContainer)
class SoNode(SoFieldContainer):
    r"""Proxy of C++ SoNode class."""

    thisown = property(lambda x: 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):
        r"""setOverride(SoNode self, SbBool const state)"""
        return _coin.SoNode_setOverride(self, state)

    def isOverride(self):
        r"""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
    

    @staticmethod
    def getCompatibilityTypes(nodetype):
        r"""getCompatibilityTypes(SoType nodetype) -> uint32_t"""
        return _coin.SoNode_getCompatibilityTypes(nodetype)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNode_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoNode_initClasses()

    @staticmethod
    def getNextNodeId():
        r"""getNextNodeId() -> uint32_t"""
        return _coin.SoNode_getNextNodeId()

    @staticmethod
    def getActionMethodIndex(type):
        r"""getActionMethodIndex(SoType type) -> int"""
        return _coin.SoNode_getActionMethodIndex(type)

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

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

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

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

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

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

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

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

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

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

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

# Register SoNode in _coin:
_coin.SoNode_swigregister(SoNode)
class SoSensorManager(object):
    r"""Proxy of C++ SoSensorManager class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSensorManager self) -> SoSensorManager"""
        _coin.SoSensorManager_swiginit(self, _coin.new_SoSensorManager())
    __swig_destroy__ = _coin.delete_SoSensorManager

    def insertDelaySensor(self, s):
        r"""insertDelaySensor(SoSensorManager self, SoDelayQueueSensor s)"""
        return _coin.SoSensorManager_insertDelaySensor(self, s)

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

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

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

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

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

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

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

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

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

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

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

    def doSelect(self, nfds, readfds, writefds, exceptfds, userTimeOut):
        r"""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):
        r"""
        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):
        r"""
        isTimerSensorPending(SoSensorManager self, SbTime tm) -> SbBool
        isTimerSensorPending(SoSensorManager self) -> PyObject *
        """
        return _coin.SoSensorManager_isTimerSensorPending(self, *args)

# Register SoSensorManager in _coin:
_coin.SoSensorManager_swigregister(SoSensorManager)
class SoDB(object):
    r"""Proxy of C++ SoDB class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def init():
        r"""init()"""
        return _coin.SoDB_init()

    @staticmethod
    def finish():
        r"""finish()"""
        return _coin.SoDB_finish()

    @staticmethod
    def cleanup():
        r"""cleanup()"""
        return _coin.SoDB_cleanup()

    @staticmethod
    def getVersion():
        r"""getVersion() -> char const *"""
        return _coin.SoDB_getVersion()

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

    @staticmethod
    def readAll(input):
        r"""readAll(SoInput input) -> SoSeparator"""
        return _coin.SoDB_readAll(input)

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

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

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

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

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

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

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

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

    @staticmethod
    def renameGlobalField(srcFrom, destTo):
        r"""renameGlobalField(SbName srcFrom, SbName destTo)"""
        return _coin.SoDB_renameGlobalField(srcFrom, destTo)

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

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

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

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

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

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

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

    @staticmethod
    def addConverter(srcFrom, destTo, converter):
        r"""addConverter(SoType srcFrom, SoType destTo, SoType converter)"""
        return _coin.SoDB_addConverter(srcFrom, destTo, converter)

    @staticmethod
    def getConverter(srcFrom, destTo):
        r"""getConverter(SoType srcFrom, SoType destTo) -> SoType"""
        return _coin.SoDB_getConverter(srcFrom, destTo)

    @staticmethod
    def isInitialized():
        r"""isInitialized() -> SbBool"""
        return _coin.SoDB_isInitialized()

    @staticmethod
    def startNotify():
        r"""startNotify()"""
        return _coin.SoDB_startNotify()

    @staticmethod
    def isNotifying():
        r"""isNotifying() -> SbBool"""
        return _coin.SoDB_isNotifying()

    @staticmethod
    def endNotify():
        r"""endNotify()"""
        return _coin.SoDB_endNotify()

    @staticmethod
    def addProgressCallback(func, userdata):
        r"""addProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
        return _coin.SoDB_addProgressCallback(func, userdata)

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

    @staticmethod
    def isMultiThread():
        r"""isMultiThread() -> SbBool"""
        return _coin.SoDB_isMultiThread()

    @staticmethod
    def readlock():
        r"""readlock()"""
        return _coin.SoDB_readlock()

    @staticmethod
    def readunlock():
        r"""readunlock()"""
        return _coin.SoDB_readunlock()

    @staticmethod
    def writelock():
        r"""writelock()"""
        return _coin.SoDB_writelock()

    @staticmethod
    def writeunlock():
        r"""writeunlock()"""
        return _coin.SoDB_writeunlock()

    @staticmethod
    def createRoute(srcFrom, eventout, destTo, eventin):
        r"""createRoute(SoNode srcFrom, char const * eventout, SoNode destTo, char const * eventin)"""
        return _coin.SoDB_createRoute(srcFrom, eventout, destTo, eventin)

    @staticmethod
    def removeRoute(srcFrom, eventout, destTo, eventin):
        r"""removeRoute(SoNode srcFrom, char const * eventout, SoNode destTo, char const * eventin)"""
        return _coin.SoDB_removeRoute(srcFrom, eventout, destTo, eventin)

    def __init__(self):
        r"""__init__(SoDB self) -> SoDB"""
        _coin.SoDB_swiginit(self, _coin.new_SoDB())
    __swig_destroy__ = _coin.delete_SoDB

# Register SoDB in _coin:
_coin.SoDB_swigregister(SoDB)
class SoInput(object):
    r"""Proxy of C++ SoInput class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoInput self) -> SoInput
        __init__(SoInput self, SoInput dictIn) -> SoInput
        """
        _coin.SoInput_swiginit(self, _coin.new_SoInput(*args))

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

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

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

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

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

    def addRoute(self, fromnode, fromfield, tonode, tofield):
        r"""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):
        r"""checkISReference(SoInput self, SoFieldContainer container, SbName fieldname, SbBool & readok) -> SbBool"""
        return _coin.SoInput_checkISReference(self, container, fieldname, readok)
    __swig_destroy__ = _coin.delete_SoInput

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def read(self, *args):
        r"""
        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, 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):
        r"""
        readByte(SoInput self, int8_t & b) -> SbBool
        readByte(SoInput self, uint8_t & b) -> SbBool
        """
        return _coin.SoInput_readByte(self, *args)

    def readBinaryArray(self, *args):
        r"""
        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):
        r"""eof(SoInput self) -> SbBool"""
        return _coin.SoInput_eof(self)

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

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

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

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

    def putBack(self, *args):
        r"""
        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):
        r"""addReference(SoInput self, SbName name, SoBase base, SbBool addToGlobalDict=1)"""
        return _coin.SoInput_addReference(self, name, base, addToGlobalDict)

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

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

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

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

    @staticmethod
    def addEnvDirectoriesFirst(*args):
        r"""addEnvDirectoriesFirst(char const * envVarName, char const * separator=":\t ")"""
        return _coin.SoInput_addEnvDirectoriesFirst(*args)

    @staticmethod
    def addEnvDirectoriesLast(*args):
        r"""addEnvDirectoriesLast(char const * envVarName, char const * separator=":\t ")"""
        return _coin.SoInput_addEnvDirectoriesLast(*args)

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

    @staticmethod
    def clearDirectories():
        r"""clearDirectories()"""
        return _coin.SoInput_clearDirectories()

    @staticmethod
    def getDirectories():
        r"""getDirectories() -> SbStringList"""
        return _coin.SoInput_getDirectories()

    @staticmethod
    def init():
        r"""init()"""
        return _coin.SoInput_init()

    @staticmethod
    def getPathname(*args):
        r"""
        getPathname(char const *const filename) -> SbString
        getPathname(SbString s) -> SbString
        """
        return _coin.SoInput_getPathname(*args)

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

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

# Register SoInput in _coin:
_coin.SoInput_swigregister(SoInput)
class SoOutput(object):
    r"""Proxy of C++ SoOutput class."""

    thisown = 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):
        r"""
        __init__(SoOutput self) -> SoOutput
        __init__(SoOutput self, SoOutput dictOut) -> SoOutput
        """
        _coin.SoOutput_swiginit(self, _coin.new_SoOutput(*args))
    __swig_destroy__ = _coin.delete_SoOutput

    def setFilePointer(self, newFP):
        r"""setFilePointer(SoOutput self, FILE * newFP)"""
        return _coin.SoOutput_setFilePointer(self, newFP)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def write(self, *args):
        r"""
        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):
        r"""
        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):
        r"""indent(SoOutput self)"""
        return _coin.SoOutput_indent(self)

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

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

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

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

    def getAnnotation(self):
        r"""getAnnotation(SoOutput self) -> uint32_t"""
        return _coin.SoOutput_getAnnotation(self)

    @staticmethod
    def getDefaultASCIIHeader():
        r"""getDefaultASCIIHeader() -> SbString"""
        return _coin.SoOutput_getDefaultASCIIHeader()

    @staticmethod
    def getDefaultBinaryHeader():
        r"""getDefaultBinaryHeader() -> SbString"""
        return _coin.SoOutput_getDefaultBinaryHeader()

    def addReference(self, base):
        r"""addReference(SoOutput self, SoBase base) -> int"""
        return _coin.SoOutput_addReference(self, base)

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

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

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

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

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

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

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

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

    def addRoute(self, srcFrom, fromfield, destTo, tofield):
        r"""addRoute(SoOutput self, SoFieldContainer srcFrom, SbName fromfield, SoFieldContainer destTo, SbName tofield)"""
        return _coin.SoOutput_addRoute(self, srcFrom, fromfield, destTo, tofield)

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

# Register SoOutput in _coin:
_coin.SoOutput_swigregister(SoOutput)
class SoSFEnum(SoSField):
    r"""Proxy of C++ SoSFEnum class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFEnum self) -> SoSFEnum"""
        _coin.SoSFEnum_swiginit(self, _coin.new_SoSFEnum())
    __swig_destroy__ = _coin.delete_SoSFEnum

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFEnum_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFEnum_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFEnum self) -> SoType"""
        return _coin.SoSFEnum_getTypeId(self)

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

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

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

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

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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFEnum_initClass()

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

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

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

    def setValue(self, *args):
        r"""
        setValue(SoSFEnum self, int newvalue)
        setValue(SoSFEnum self, SbName name)
        setValue(SoSFEnum self, SoSFEnum other)
        """
        return _coin.SoSFEnum_setValue(self, *args)

# Register SoSFEnum in _coin:
_coin.SoSFEnum_swigregister(SoSFEnum)
class SoSFFloat(SoSField):
    r"""Proxy of C++ SoSFFloat class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFFloat self) -> SoSFFloat"""
        _coin.SoSFFloat_swiginit(self, _coin.new_SoSFFloat())
    __swig_destroy__ = _coin.delete_SoSFFloat

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFFloat_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFFloat_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFFloat self) -> SoType"""
        return _coin.SoSFFloat_getTypeId(self)

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

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

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

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

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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFFloat_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFFloat self, float newvalue)
        setValue(SoSFFloat self, SoSFFloat other)
        """
        return _coin.SoSFFloat_setValue(self, *args)

# Register SoSFFloat in _coin:
_coin.SoSFFloat_swigregister(SoSFFloat)
class SoComplexityTypeElement(SoInt32Element):
    r"""Proxy of C++ SoComplexityTypeElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComplexityTypeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoComplexityTypeElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComplexityTypeElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComplexityTypeElement_initClass()
    OBJECT_SPACE = _coin.SoComplexityTypeElement_OBJECT_SPACE
    
    SCREEN_SPACE = _coin.SoComplexityTypeElement_SCREEN_SPACE
    
    BOUNDING_BOX = _coin.SoComplexityTypeElement_BOUNDING_BOX
    

    def init(self, state):
        r"""init(SoComplexityTypeElement self, SoState state)"""
        return _coin.SoComplexityTypeElement_init(self, state)

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

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

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoComplexityTypeElement::Type"""
        return _coin.SoComplexityTypeElement_getDefault()

# Register SoComplexityTypeElement in _coin:
_coin.SoComplexityTypeElement_swigregister(SoComplexityTypeElement)
class SoComplexity(SoNode):
    r"""Proxy of C++ SoComplexity class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComplexity_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoComplexity self) -> SoType"""
        return _coin.SoComplexity_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComplexity_initClass()

    def __init__(self):
        r"""__init__(SoComplexity self) -> SoComplexity"""
        _coin.SoComplexity_swiginit(self, _coin.new_SoComplexity())
    OBJECT_SPACE = _coin.SoComplexity_OBJECT_SPACE
    
    SCREEN_SPACE = _coin.SoComplexity_SCREEN_SPACE
    
    BOUNDING_BOX = _coin.SoComplexity_BOUNDING_BOX
    
    type = property(_coin.SoComplexity_type_get, _coin.SoComplexity_type_set, doc=r"""type : SoSFEnum""")
    value = property(_coin.SoComplexity_value_get, _coin.SoComplexity_value_set, doc=r"""value : SoSFFloat""")
    textureQuality = property(_coin.SoComplexity_textureQuality_get, _coin.SoComplexity_textureQuality_set, doc=r"""textureQuality : SoSFFloat""")

    def doAction(self, action):
        r"""doAction(SoComplexity self, SoAction action)"""
        return _coin.SoComplexity_doAction(self, action)

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

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

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

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

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

# Register SoComplexity in _coin:
_coin.SoComplexity_swigregister(SoComplexity)
class SoDrawStyleElement(SoInt32Element):
    r"""Proxy of C++ SoDrawStyleElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDrawStyleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoDrawStyleElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDrawStyleElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDrawStyleElement_initClass()
    FILLED = _coin.SoDrawStyleElement_FILLED
    
    LINES = _coin.SoDrawStyleElement_LINES
    
    POINTS = _coin.SoDrawStyleElement_POINTS
    
    INVISIBLE = _coin.SoDrawStyleElement_INVISIBLE
    

    def init(self, state):
        r"""init(SoDrawStyleElement self, SoState state)"""
        return _coin.SoDrawStyleElement_init(self, state)

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

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

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoDrawStyleElement::Style"""
        return _coin.SoDrawStyleElement_getDefault()

# Register SoDrawStyleElement in _coin:
_coin.SoDrawStyleElement_swigregister(SoDrawStyleElement)
class SoSFUShort(SoSField):
    r"""Proxy of C++ SoSFUShort class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFUShort self) -> SoSFUShort"""
        _coin.SoSFUShort_swiginit(self, _coin.new_SoSFUShort())
    __swig_destroy__ = _coin.delete_SoSFUShort

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFUShort_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFUShort_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFUShort self) -> SoType"""
        return _coin.SoSFUShort_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFUShort self, SoField field)"""
        return _coin.SoSFUShort_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFUShort self, SoField field) -> SbBool"""
        return _coin.SoSFUShort_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFUShort self) -> unsigned short"""
        return _coin.SoSFUShort_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFUShort self, SoSFUShort field) -> int"""
        return _coin.SoSFUShort___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFUShort self, SoSFUShort field) -> int"""
        return _coin.SoSFUShort___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFUShort_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFUShort self, unsigned short newvalue)
        setValue(SoSFUShort self, SoSFUShort other)
        """
        return _coin.SoSFUShort_setValue(self, *args)

# Register SoSFUShort in _coin:
_coin.SoSFUShort_swigregister(SoSFUShort)
class SoSFInt32(SoSField):
    r"""Proxy of C++ SoSFInt32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFInt32 self) -> SoSFInt32"""
        _coin.SoSFInt32_swiginit(self, _coin.new_SoSFInt32())
    __swig_destroy__ = _coin.delete_SoSFInt32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFInt32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFInt32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFInt32 self) -> SoType"""
        return _coin.SoSFInt32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFInt32 self, SoField field)"""
        return _coin.SoSFInt32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFInt32 self, SoField field) -> SbBool"""
        return _coin.SoSFInt32_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFInt32 self) -> int32_t"""
        return _coin.SoSFInt32_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFInt32 self, SoSFInt32 field) -> int"""
        return _coin.SoSFInt32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFInt32 self, SoSFInt32 field) -> int"""
        return _coin.SoSFInt32___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFInt32_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFInt32 self, int32_t newvalue)
        setValue(SoSFInt32 self, SoSFInt32 other)
        """
        return _coin.SoSFInt32_setValue(self, *args)

# Register SoSFInt32 in _coin:
_coin.SoSFInt32_swigregister(SoSFInt32)
class SoDrawStyle(SoNode):
    r"""Proxy of C++ SoDrawStyle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDrawStyle_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDrawStyle self) -> SoType"""
        return _coin.SoDrawStyle_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDrawStyle_initClass()

    def __init__(self):
        r"""__init__(SoDrawStyle self) -> SoDrawStyle"""
        _coin.SoDrawStyle_swiginit(self, _coin.new_SoDrawStyle())
    FILLED = _coin.SoDrawStyle_FILLED
    
    LINES = _coin.SoDrawStyle_LINES
    
    POINTS = _coin.SoDrawStyle_POINTS
    
    INVISIBLE = _coin.SoDrawStyle_INVISIBLE
    
    style = property(_coin.SoDrawStyle_style_get, _coin.SoDrawStyle_style_set, doc=r"""style : SoSFEnum""")
    pointSize = property(_coin.SoDrawStyle_pointSize_get, _coin.SoDrawStyle_pointSize_set, doc=r"""pointSize : SoSFFloat""")
    lineWidth = property(_coin.SoDrawStyle_lineWidth_get, _coin.SoDrawStyle_lineWidth_set, doc=r"""lineWidth : SoSFFloat""")
    linePattern = property(_coin.SoDrawStyle_linePattern_get, _coin.SoDrawStyle_linePattern_set, doc=r"""linePattern : SoSFUShort""")
    linePatternScaleFactor = property(_coin.SoDrawStyle_linePatternScaleFactor_get, _coin.SoDrawStyle_linePatternScaleFactor_set, doc=r"""linePatternScaleFactor : SoSFInt32""")

    def doAction(self, action):
        r"""doAction(SoDrawStyle self, SoAction action)"""
        return _coin.SoDrawStyle_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoDrawStyle self, SoGLRenderAction action)"""
        return _coin.SoDrawStyle_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoDrawStyle self, SoCallbackAction action)"""
        return _coin.SoDrawStyle_callback(self, action)

# Register SoDrawStyle in _coin:
_coin.SoDrawStyle_swigregister(SoDrawStyle)
class SbVec3f(object):
    r"""Proxy of C++ SbVec3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec3f_swiginit(self, _coin.new_SbVec3f(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""getValue(SbVec3f self) -> float const *"""
        return _coin.SbVec3f_getValue(self)

    def equals(self, v, tolerance):
        r"""equals(SbVec3f self, SbVec3f v, float tolerance) -> SbBool"""
        return _coin.SbVec3f_equals(self, v, tolerance)

    def cross(self, v):
        r"""cross(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f_cross(self, v)

    def dot(self, v):
        r"""dot(SbVec3f self, SbVec3f v) -> float"""
        return _coin.SbVec3f_dot(self, v)

    def getClosestAxis(self):
        r"""getClosestAxis(SbVec3f self) -> SbVec3f"""
        return _coin.SbVec3f_getClosestAxis(self)

    def length(self):
        r"""length(SbVec3f self) -> float"""
        return _coin.SbVec3f_length(self)

    def sqrLength(self):
        r"""sqrLength(SbVec3f self) -> float"""
        return _coin.SbVec3f_sqrLength(self)

    def normalize(self):
        r"""normalize(SbVec3f self) -> float"""
        return _coin.SbVec3f_normalize(self)

    def negate(self):
        r"""negate(SbVec3f self)"""
        return _coin.SbVec3f_negate(self)

    def __imul__(self, d):
        r"""__imul__(SbVec3f self, float d) -> SbVec3f"""
        return _coin.SbVec3f___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec3f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec3f self, SbVec3f v) -> SbVec3f"""
        return _coin.SbVec3f___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec3f self) -> SbVec3f"""
        return _coin.SbVec3f___neg__(self)

    def output(self, fp):
        r"""output(SbVec3f self, FILE * fp)"""
        return _coin.SbVec3f_output(self, fp)

    def __add__(self, u):
        r"""__add__(SbVec3f self, SbVec3f u) -> SbVec3f"""
        return _coin.SbVec3f___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbVec3f self, SbVec3f u) -> SbVec3f"""
        return _coin.SbVec3f___sub__(self, u)

    def __mul__(self, *args):
        r"""
        __mul__(SbVec3f self, float const d) -> SbVec3f
        __mul__(SbVec3f self, SbMatrix m) -> SbVec3f
        """
        return _coin.SbVec3f___mul__(self, *args)

    def __rmul__(self, d):
        r"""__rmul__(SbVec3f self, float const d) -> SbVec3f"""
        return _coin.SbVec3f___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbVec3f self, float const d) -> SbVec3f"""
        return _coin.SbVec3f___div__(self, d)

    def __truediv__(self, d):
        r"""__truediv__(SbVec3f self, float const d) -> SbVec3f"""
        return _coin.SbVec3f___truediv__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbVec3f self, SbVec3f u) -> int"""
        return _coin.SbVec3f___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbVec3f self, SbVec3f u) -> int"""
        return _coin.SbVec3f___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbVec3f self, int i) -> float"""
        return _coin.SbVec3f___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__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

# Register SbVec3f in _coin:
_coin.SbVec3f_swigregister(SbVec3f)
class SbColor(SbVec3f):
    r"""Proxy of C++ SbColor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbColor_swiginit(self, _coin.new_SbColor(*args))

    def setHSVValue(self, *args):
        r"""
        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):
        r"""getHSVValue(SbColor self)"""
        return _coin.SbColor_getHSVValue(self)

    def setPackedValue(self, rgba, transparency):
        r"""setPackedValue(SbColor self, uint32_t const rgba, float & transparency) -> SbColor"""
        return _coin.SbColor_setPackedValue(self, rgba, transparency)

    def getPackedValue(self, transparency=0.0):
        r"""getPackedValue(SbColor self, float const transparency=0.0) -> uint32_t"""
        return _coin.SbColor_getPackedValue(self, transparency)

    def __add__(self, u):
        r"""__add__(SbColor self, SbColor u) -> SbColor"""
        return _coin.SbColor___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbColor self, SbColor u) -> SbColor"""
        return _coin.SbColor___sub__(self, u)

    def __mul__(self, d):
        r"""__mul__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___mul__(self, d)

    def __rmul__(self, d):
        r"""__rmul__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbColor self, float const d) -> SbColor"""
        return _coin.SbColor___div__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbColor self, SbColor u) -> int"""
        return _coin.SbColor___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbColor self, SbColor u) -> int"""
        return _coin.SbColor___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbColor self, int i) -> float"""
        return _coin.SbColor___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SbColor self, int i, float value)"""
        return _coin.SbColor___setitem__(self, i, value)
    __swig_destroy__ = _coin.delete_SbColor

# Register SbColor in _coin:
_coin.SbColor_swigregister(SbColor)
SO_LAZY_SHINY_THRESHOLD = _coin.SO_LAZY_SHINY_THRESHOLD

class SoLazyElement(SoElement):
    r"""Proxy of C++ SoLazyElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLazyElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoLazyElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoLazyElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLazyElement_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):
        r"""init(SoLazyElement self, SoState state)"""
        return _coin.SoLazyElement_init(self, state)

    def push(self, state):
        r"""push(SoLazyElement self, SoState state)"""
        return _coin.SoLazyElement_push(self, state)

    def matches(self, arg2):
        r"""matches(SoLazyElement self, SoElement arg2) -> SbBool"""
        return _coin.SoLazyElement_matches(self, arg2)

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoLazyElement self) -> SoElement"""
        return _coin.SoLazyElement_copyMatchInfo(self)

    @staticmethod
    def setToDefault(state):
        r"""setToDefault(SoState state)"""
        return _coin.SoLazyElement_setToDefault(state)

    @staticmethod
    def setDiffuse(state, node, numcolors, colors, packer):
        r"""setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
        return _coin.SoLazyElement_setDiffuse(state, node, numcolors, colors, packer)

    @staticmethod
    def setTransparency(state, node, numvalues, transparency, packer):
        r"""setTransparency(SoState state, SoNode node, int32_t numvalues, float const * transparency, SoColorPacker packer)"""
        return _coin.SoLazyElement_setTransparency(state, node, numvalues, transparency, packer)

    @staticmethod
    def setColorIndices(state, node, numindices, indices):
        r"""setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t const * indices)"""
        return _coin.SoLazyElement_setColorIndices(state, node, numindices, indices)

    @staticmethod
    def setAmbient(state, color):
        r"""setAmbient(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setAmbient(state, color)

    @staticmethod
    def setEmissive(state, color):
        r"""setEmissive(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setEmissive(state, color)

    @staticmethod
    def setSpecular(state, color):
        r"""setSpecular(SoState state, SbColor color)"""
        return _coin.SoLazyElement_setSpecular(state, color)

    @staticmethod
    def setShininess(state, value):
        r"""setShininess(SoState state, float value)"""
        return _coin.SoLazyElement_setShininess(state, value)

    @staticmethod
    def setColorMaterial(state, value):
        r"""setColorMaterial(SoState state, SbBool value)"""
        return _coin.SoLazyElement_setColorMaterial(state, value)

    @staticmethod
    def enableBlending(state, sfactor, dfactor):
        r"""enableBlending(SoState state, int sfactor, int dfactor)"""
        return _coin.SoLazyElement_enableBlending(state, sfactor, dfactor)

    @staticmethod
    def enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor):
        r"""enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
        return _coin.SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor)

    @staticmethod
    def disableBlending(state):
        r"""disableBlending(SoState state)"""
        return _coin.SoLazyElement_disableBlending(state)

    @staticmethod
    def setLightModel(state, model):
        r"""setLightModel(SoState state, int32_t const model)"""
        return _coin.SoLazyElement_setLightModel(state, model)

    @staticmethod
    def setVertexOrdering(state, ordering):
        r"""setVertexOrdering(SoState state, SoLazyElement::VertexOrdering ordering)"""
        return _coin.SoLazyElement_setVertexOrdering(state, ordering)

    @staticmethod
    def setBackfaceCulling(state, onoff):
        r"""setBackfaceCulling(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setBackfaceCulling(state, onoff)

    @staticmethod
    def setTwosideLighting(state, onoff):
        r"""setTwosideLighting(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setTwosideLighting(state, onoff)

    @staticmethod
    def setShadeModel(state, flatshading):
        r"""setShadeModel(SoState state, SbBool flatshading)"""
        return _coin.SoLazyElement_setShadeModel(state, flatshading)

    @staticmethod
    def setGLImageId(state, glimageid, alphatest):
        r"""setGLImageId(SoState state, uint32_t glimageid, SbBool alphatest)"""
        return _coin.SoLazyElement_setGLImageId(state, glimageid, alphatest)

    @staticmethod
    def setAlphaTest(state, onoff):
        r"""setAlphaTest(SoState state, SbBool onoff)"""
        return _coin.SoLazyElement_setAlphaTest(state, onoff)

    @staticmethod
    def getDiffuse(state, index):
        r"""getDiffuse(SoState state, int index) -> SbColor"""
        return _coin.SoLazyElement_getDiffuse(state, index)

    @staticmethod
    def getTransparency(arg1, index):
        r"""getTransparency(SoState arg1, int index) -> float"""
        return _coin.SoLazyElement_getTransparency(arg1, index)

    @staticmethod
    def getPackedColors(arg1):
        r"""getPackedColors(SoState arg1) -> uint32_t const *"""
        return _coin.SoLazyElement_getPackedColors(arg1)

    @staticmethod
    def getColorIndices(arg1):
        r"""getColorIndices(SoState arg1) -> int32_t const *"""
        return _coin.SoLazyElement_getColorIndices(arg1)

    @staticmethod
    def getColorIndex(arg1, num):
        r"""getColorIndex(SoState arg1, int num) -> int32_t"""
        return _coin.SoLazyElement_getColorIndex(arg1, num)

    @staticmethod
    def getAmbient(arg1):
        r"""getAmbient(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getAmbient(arg1)

    @staticmethod
    def getEmissive(arg1):
        r"""getEmissive(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getEmissive(arg1)

    @staticmethod
    def getSpecular(arg1):
        r"""getSpecular(SoState arg1) -> SbColor"""
        return _coin.SoLazyElement_getSpecular(arg1)

    @staticmethod
    def getShininess(arg1):
        r"""getShininess(SoState arg1) -> float"""
        return _coin.SoLazyElement_getShininess(arg1)

    @staticmethod
    def getColorMaterial(arg1):
        r"""getColorMaterial(SoState arg1) -> SbBool"""
        return _coin.SoLazyElement_getColorMaterial(arg1)

    @staticmethod
    def getBlending(arg1, sfactor, dfactor):
        r"""getBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
        return _coin.SoLazyElement_getBlending(arg1, sfactor, dfactor)

    @staticmethod
    def getAlphaBlending(arg1, sfactor, dfactor):
        r"""getAlphaBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
        return _coin.SoLazyElement_getAlphaBlending(arg1, sfactor, dfactor)

    @staticmethod
    def getLightModel(arg1):
        r"""getLightModel(SoState arg1) -> int32_t"""
        return _coin.SoLazyElement_getLightModel(arg1)

    @staticmethod
    def getAlphaTest(state):
        r"""getAlphaTest(SoState state) -> SbBool"""
        return _coin.SoLazyElement_getAlphaTest(state)

    def getNumDiffuse(self):
        r"""getNumDiffuse(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumDiffuse(self)

    def getNumTransparencies(self):
        r"""getNumTransparencies(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumTransparencies(self)

    def getNumColorIndices(self):
        r"""getNumColorIndices(SoLazyElement self) -> int32_t"""
        return _coin.SoLazyElement_getNumColorIndices(self)

    def isPacked(self):
        r"""isPacked(SoLazyElement self) -> SbBool"""
        return _coin.SoLazyElement_isPacked(self)

    def isTransparent(self):
        r"""isTransparent(SoLazyElement self) -> SbBool"""
        return _coin.SoLazyElement_isTransparent(self)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoLazyElement"""
        return _coin.SoLazyElement_getInstance(state)

    @staticmethod
    def getDefaultAmbientIntensity():
        r"""getDefaultAmbientIntensity() -> float"""
        return _coin.SoLazyElement_getDefaultAmbientIntensity()

    @staticmethod
    def getDefaultDiffuse():
        r"""getDefaultDiffuse() -> SbColor"""
        return _coin.SoLazyElement_getDefaultDiffuse()

    @staticmethod
    def getDefaultAmbient():
        r"""getDefaultAmbient() -> SbColor"""
        return _coin.SoLazyElement_getDefaultAmbient()

    @staticmethod
    def getDefaultSpecular():
        r"""getDefaultSpecular() -> SbColor"""
        return _coin.SoLazyElement_getDefaultSpecular()

    @staticmethod
    def getDefaultEmissive():
        r"""getDefaultEmissive() -> SbColor"""
        return _coin.SoLazyElement_getDefaultEmissive()

    @staticmethod
    def getDefaultShininess():
        r"""getDefaultShininess() -> float"""
        return _coin.SoLazyElement_getDefaultShininess()

    @staticmethod
    def getDefaultPacked():
        r"""getDefaultPacked() -> uint32_t"""
        return _coin.SoLazyElement_getDefaultPacked()

    @staticmethod
    def getDefaultTransparency():
        r"""getDefaultTransparency() -> float"""
        return _coin.SoLazyElement_getDefaultTransparency()

    @staticmethod
    def getDefaultLightModel():
        r"""getDefaultLightModel() -> int32_t"""
        return _coin.SoLazyElement_getDefaultLightModel()

    @staticmethod
    def getDefaultColorIndex():
        r"""getDefaultColorIndex() -> int32_t"""
        return _coin.SoLazyElement_getDefaultColorIndex()

    @staticmethod
    def setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent):
        r"""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)

    @staticmethod
    def getWInstance(state):
        r"""getWInstance(SoState state) -> SoLazyElement"""
        return _coin.SoLazyElement_getWInstance(state)

    def getPackedPointer(self):
        r"""getPackedPointer(SoLazyElement self) -> uint32_t const *"""
        return _coin.SoLazyElement_getPackedPointer(self)

    def getDiffusePointer(self):
        r"""getDiffusePointer(SoLazyElement self) -> SbColor"""
        return _coin.SoLazyElement_getDiffusePointer(self)

    def getColorIndexPointer(self):
        r"""getColorIndexPointer(SoLazyElement self) -> int32_t const *"""
        return _coin.SoLazyElement_getColorIndexPointer(self)

    def getTransparencyPointer(self):
        r"""getTransparencyPointer(SoLazyElement self) -> float const *"""
        return _coin.SoLazyElement_getTransparencyPointer(self)

    @staticmethod
    def setTransparencyType(state, type):
        r"""setTransparencyType(SoState state, int32_t type)"""
        return _coin.SoLazyElement_setTransparencyType(state, type)

# Register SoLazyElement in _coin:
_coin.SoLazyElement_swigregister(SoLazyElement)
class SoColorPacker(object):
    r"""Proxy of C++ SoColorPacker class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoColorPacker self) -> SoColorPacker"""
        _coin.SoColorPacker_swiginit(self, _coin.new_SoColorPacker())
    __swig_destroy__ = _coin.delete_SoColorPacker

    def getPackedColors(self):
        r"""getPackedColors(SoColorPacker self) -> uint32_t *"""
        return _coin.SoColorPacker_getPackedColors(self)

    def diffuseMatch(self, nodeid):
        r"""diffuseMatch(SoColorPacker self, uint32_t const nodeid) -> SbBool"""
        return _coin.SoColorPacker_diffuseMatch(self, nodeid)

    def transpMatch(self, nodeid):
        r"""transpMatch(SoColorPacker self, uint32_t const nodeid) -> SbBool"""
        return _coin.SoColorPacker_transpMatch(self, nodeid)

    def setNodeIds(self, diffuse, transp):
        r"""setNodeIds(SoColorPacker self, uint32_t const diffuse, uint32_t const transp)"""
        return _coin.SoColorPacker_setNodeIds(self, diffuse, transp)

    def getSize(self):
        r"""getSize(SoColorPacker self) -> int32_t"""
        return _coin.SoColorPacker_getSize(self)

    def reallocate(self, size):
        r"""reallocate(SoColorPacker self, int32_t const size)"""
        return _coin.SoColorPacker_reallocate(self, size)

    def getDiffuseId(self):
        r"""getDiffuseId(SoColorPacker self) -> uint32_t"""
        return _coin.SoColorPacker_getDiffuseId(self)

    def getTranspId(self):
        r"""getTranspId(SoColorPacker self) -> uint32_t"""
        return _coin.SoColorPacker_getTranspId(self)

# Register SoColorPacker in _coin:
_coin.SoColorPacker_swigregister(SoColorPacker)
class SoLightModel(SoNode):
    r"""Proxy of C++ SoLightModel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightModel_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLightModel self) -> SoType"""
        return _coin.SoLightModel_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLightModel_initClass()

    def __init__(self):
        r"""__init__(SoLightModel self) -> SoLightModel"""
        _coin.SoLightModel_swiginit(self, _coin.new_SoLightModel())
    BASE_COLOR = _coin.SoLightModel_BASE_COLOR
    
    PHONG = _coin.SoLightModel_PHONG
    
    model = property(_coin.SoLightModel_model_get, _coin.SoLightModel_model_set, doc=r"""model : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoLightModel self, SoAction action)"""
        return _coin.SoLightModel_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoLightModel self, SoGLRenderAction action)"""
        return _coin.SoLightModel_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoLightModel self, SoCallbackAction action)"""
        return _coin.SoLightModel_callback(self, action)

# Register SoLightModel in _coin:
_coin.SoLightModel_swigregister(SoLightModel)
class SoMaterialBindingElement(SoInt32Element):
    r"""Proxy of C++ SoMaterialBindingElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMaterialBindingElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoMaterialBindingElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMaterialBindingElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMaterialBindingElement_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):
        r"""init(SoMaterialBindingElement self, SoState state)"""
        return _coin.SoMaterialBindingElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, SoMaterialBindingElement::Binding const binding)
        set(SoState state, SoMaterialBindingElement::Binding const binding)
        """
        return _coin.SoMaterialBindingElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoMaterialBindingElement::Binding"""
        return _coin.SoMaterialBindingElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoMaterialBindingElement::Binding"""
        return _coin.SoMaterialBindingElement_getDefault()

# Register SoMaterialBindingElement in _coin:
_coin.SoMaterialBindingElement_swigregister(SoMaterialBindingElement)
class SoMaterialBinding(SoNode):
    r"""Proxy of C++ SoMaterialBinding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMaterialBinding_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMaterialBinding self) -> SoType"""
        return _coin.SoMaterialBinding_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMaterialBinding_initClass()

    def __init__(self):
        r"""__init__(SoMaterialBinding self) -> SoMaterialBinding"""
        _coin.SoMaterialBinding_swiginit(self, _coin.new_SoMaterialBinding())
    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 = property(_coin.SoMaterialBinding_value_get, _coin.SoMaterialBinding_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoMaterialBinding self, SoAction action)"""
        return _coin.SoMaterialBinding_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoMaterialBinding self, SoGLRenderAction action)"""
        return _coin.SoMaterialBinding_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoMaterialBinding self, SoCallbackAction action)"""
        return _coin.SoMaterialBinding_callback(self, action)

    def pick(self, action):
        r"""pick(SoMaterialBinding self, SoPickAction action)"""
        return _coin.SoMaterialBinding_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoMaterialBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMaterialBinding_getPrimitiveCount(self, action)

# Register SoMaterialBinding in _coin:
_coin.SoMaterialBinding_swigregister(SoMaterialBinding)
class SoNormalBindingElement(SoInt32Element):
    r"""Proxy of C++ SoNormalBindingElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNormalBindingElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoNormalBindingElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoNormalBindingElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNormalBindingElement_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):
        r"""init(SoNormalBindingElement self, SoState state)"""
        return _coin.SoNormalBindingElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, SoNormalBindingElement::Binding const binding)
        set(SoState state, SoNormalBindingElement::Binding const binding)
        """
        return _coin.SoNormalBindingElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoNormalBindingElement::Binding"""
        return _coin.SoNormalBindingElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoNormalBindingElement::Binding"""
        return _coin.SoNormalBindingElement_getDefault()

# Register SoNormalBindingElement in _coin:
_coin.SoNormalBindingElement_swigregister(SoNormalBindingElement)
class SoNormalBinding(SoNode):
    r"""Proxy of C++ SoNormalBinding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNormalBinding_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoNormalBinding self) -> SoType"""
        return _coin.SoNormalBinding_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNormalBinding_initClass()

    def __init__(self):
        r"""__init__(SoNormalBinding self) -> SoNormalBinding"""
        _coin.SoNormalBinding_swiginit(self, _coin.new_SoNormalBinding())
    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 = property(_coin.SoNormalBinding_value_get, _coin.SoNormalBinding_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoNormalBinding self, SoAction action)"""
        return _coin.SoNormalBinding_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoNormalBinding self, SoGLRenderAction action)"""
        return _coin.SoNormalBinding_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoNormalBinding self, SoCallbackAction action)"""
        return _coin.SoNormalBinding_callback(self, action)

    def pick(self, action):
        r"""pick(SoNormalBinding self, SoPickAction action)"""
        return _coin.SoNormalBinding_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoNormalBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNormalBinding_getPrimitiveCount(self, action)

# Register SoNormalBinding in _coin:
_coin.SoNormalBinding_swigregister(SoNormalBinding)
class SoPickStyleElement(SoInt32Element):
    r"""Proxy of C++ SoPickStyleElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPickStyleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoPickStyleElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoPickStyleElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPickStyleElement_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):
        r"""init(SoPickStyleElement self, SoState state)"""
        return _coin.SoPickStyleElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, int32_t const style)
        set(SoState state, SoPickStyleElement::Style const style)
        """
        return _coin.SoPickStyleElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoPickStyleElement::Style"""
        return _coin.SoPickStyleElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoPickStyleElement::Style"""
        return _coin.SoPickStyleElement_getDefault()

# Register SoPickStyleElement in _coin:
_coin.SoPickStyleElement_swigregister(SoPickStyleElement)
class SoPickStyle(SoNode):
    r"""Proxy of C++ SoPickStyle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPickStyle_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPickStyle self) -> SoType"""
        return _coin.SoPickStyle_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPickStyle_initClass()

    def __init__(self):
        r"""__init__(SoPickStyle self) -> SoPickStyle"""
        _coin.SoPickStyle_swiginit(self, _coin.new_SoPickStyle())
    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 = property(_coin.SoPickStyle_style_get, _coin.SoPickStyle_style_set, doc=r"""style : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoPickStyle self, SoAction action)"""
        return _coin.SoPickStyle_doAction(self, action)

    def callback(self, action):
        r"""callback(SoPickStyle self, SoCallbackAction action)"""
        return _coin.SoPickStyle_callback(self, action)

    def pick(self, action):
        r"""pick(SoPickStyle self, SoPickAction action)"""
        return _coin.SoPickStyle_pick(self, action)

# Register SoPickStyle in _coin:
_coin.SoPickStyle_swigregister(SoPickStyle)
class SoShapeHintsElement(SoElement):
    r"""Proxy of C++ SoShapeHintsElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShapeHintsElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoShapeHintsElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoShapeHintsElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShapeHintsElement_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):
        r"""init(SoShapeHintsElement self, SoState state)"""
        return _coin.SoShapeHintsElement_init(self, state)

    def push(self, state):
        r"""push(SoShapeHintsElement self, SoState state)"""
        return _coin.SoShapeHintsElement_push(self, state)

    def pop(self, state, prevtopelement):
        r"""pop(SoShapeHintsElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoShapeHintsElement_pop(self, state, prevtopelement)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoShapeHintsElement self) -> SoElement"""
        return _coin.SoShapeHintsElement_copyMatchInfo(self)

    @staticmethod
    def set(*args):
        r"""
        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)

    @staticmethod
    def get(state, vertexOrdering, shapeType, faceType):
        r"""get(SoState state, SoShapeHintsElement::VertexOrdering & vertexOrdering, SoShapeHintsElement::ShapeType & shapeType, SoShapeHintsElement::FaceType & faceType)"""
        return _coin.SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType)

    @staticmethod
    def getVertexOrdering(state):
        r"""getVertexOrdering(SoState state) -> SoShapeHintsElement::VertexOrdering"""
        return _coin.SoShapeHintsElement_getVertexOrdering(state)

    @staticmethod
    def getShapeType(state):
        r"""getShapeType(SoState state) -> SoShapeHintsElement::ShapeType"""
        return _coin.SoShapeHintsElement_getShapeType(state)

    @staticmethod
    def getFaceType(state):
        r"""getFaceType(SoState state) -> SoShapeHintsElement::FaceType"""
        return _coin.SoShapeHintsElement_getFaceType(state)

    @staticmethod
    def getDefaultVertexOrdering():
        r"""getDefaultVertexOrdering() -> SoShapeHintsElement::VertexOrdering"""
        return _coin.SoShapeHintsElement_getDefaultVertexOrdering()

    @staticmethod
    def getDefaultShapeType():
        r"""getDefaultShapeType() -> SoShapeHintsElement::ShapeType"""
        return _coin.SoShapeHintsElement_getDefaultShapeType()

    @staticmethod
    def getDefaultFaceType():
        r"""getDefaultFaceType() -> SoShapeHintsElement::FaceType"""
        return _coin.SoShapeHintsElement_getDefaultFaceType()

    def output(self, file):
        r"""output(SoShapeHintsElement self, FILE * file)"""
        return _coin.SoShapeHintsElement_output(self, file)

# Register SoShapeHintsElement in _coin:
_coin.SoShapeHintsElement_swigregister(SoShapeHintsElement)
class SoSFBool(SoSField):
    r"""Proxy of C++ SoSFBool class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBool self) -> SoSFBool"""
        _coin.SoSFBool_swiginit(self, _coin.new_SoSFBool())
    __swig_destroy__ = _coin.delete_SoSFBool

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBool_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBool_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBool self) -> SoType"""
        return _coin.SoSFBool_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBool self, SoField field)"""
        return _coin.SoSFBool_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBool self, SoField field) -> SbBool"""
        return _coin.SoSFBool_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFBool self) -> SbBool"""
        return _coin.SoSFBool_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFBool self, SoSFBool field) -> int"""
        return _coin.SoSFBool___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBool self, SoSFBool field) -> int"""
        return _coin.SoSFBool___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBool_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFBool self, SbBool newvalue)
        setValue(SoSFBool self, SoSFBool other)
        """
        return _coin.SoSFBool_setValue(self, *args)

# Register SoSFBool in _coin:
_coin.SoSFBool_swigregister(SoSFBool)
class SoShapeHints(SoNode):
    r"""Proxy of C++ SoShapeHints class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShapeHints_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShapeHints self) -> SoType"""
        return _coin.SoShapeHints_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShapeHints_initClass()

    def __init__(self):
        r"""__init__(SoShapeHints self) -> SoShapeHints"""
        _coin.SoShapeHints_swiginit(self, _coin.new_SoShapeHints())
    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 = property(_coin.SoShapeHints_vertexOrdering_get, _coin.SoShapeHints_vertexOrdering_set, doc=r"""vertexOrdering : SoSFEnum""")
    shapeType = property(_coin.SoShapeHints_shapeType_get, _coin.SoShapeHints_shapeType_set, doc=r"""shapeType : SoSFEnum""")
    faceType = property(_coin.SoShapeHints_faceType_get, _coin.SoShapeHints_faceType_set, doc=r"""faceType : SoSFEnum""")
    windingType = property(_coin.SoShapeHints_windingType_get, _coin.SoShapeHints_windingType_set, doc=r"""windingType : SoSFEnum""")
    useVBO = property(_coin.SoShapeHints_useVBO_get, _coin.SoShapeHints_useVBO_set, doc=r"""useVBO : SoSFBool""")
    creaseAngle = property(_coin.SoShapeHints_creaseAngle_get, _coin.SoShapeHints_creaseAngle_set, doc=r"""creaseAngle : SoSFFloat""")

    def doAction(self, action):
        r"""doAction(SoShapeHints self, SoAction action)"""
        return _coin.SoShapeHints_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoShapeHints self, SoGLRenderAction action)"""
        return _coin.SoShapeHints_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoShapeHints self, SoCallbackAction action)"""
        return _coin.SoShapeHints_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoShapeHints self, SoGetBoundingBoxAction action)"""
        return _coin.SoShapeHints_getBoundingBox(self, action)

    def pick(self, action):
        r"""pick(SoShapeHints self, SoPickAction action)"""
        return _coin.SoShapeHints_pick(self, action)

# Register SoShapeHints in _coin:
_coin.SoShapeHints_swigregister(SoShapeHints)
class SoTexture(SoNode):
    r"""Proxy of C++ SoTexture class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTexture self) -> SoType"""
        return _coin.SoTexture_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTexture_initClass()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoTexture_cleanupClass()

    def doAction(self, action):
        r"""doAction(SoTexture self, SoAction action)"""
        return _coin.SoTexture_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTexture self, SoGLRenderAction action)"""
        return _coin.SoTexture_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTexture self, SoCallbackAction action)"""
        return _coin.SoTexture_callback(self, action)

# Register SoTexture in _coin:
_coin.SoTexture_swigregister(SoTexture)
class SoSFImage(SoSField):
    r"""Proxy of C++ SoSFImage class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFImage self) -> SoSFImage"""
        _coin.SoSFImage_swiginit(self, _coin.new_SoSFImage())
    __swig_destroy__ = _coin.delete_SoSFImage

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFImage_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFImage_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFImage self) -> SoType"""
        return _coin.SoSFImage_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFImage self, SoField field)"""
        return _coin.SoSFImage_copyFrom(self, field)

    def isSame(self, field):
        r"""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
    

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFImage_initClass()

    def getValue(self, *args):
        r"""
        getValue(SoSFImage self) -> unsigned char const
        getValue(SoSFImage self) -> SbImage
        """
        return _coin.SoSFImage_getValue(self, *args)

    def __eq__(self, field):
        r"""__eq__(SoSFImage self, SoSFImage field) -> int"""
        return _coin.SoSFImage___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFImage self, SoSFImage field) -> int"""
        return _coin.SoSFImage___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoSFImage self) -> unsigned char *"""
        return _coin.SoSFImage_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoSFImage self)"""
        return _coin.SoSFImage_finishEditing(self)

    def setSubValue(self, dims, offset, pixels):
        r"""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):
        r"""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):
        r"""getSubTexture(SoSFImage self, int idx, SbVec2s dims, SbVec2s offset) -> unsigned char *"""
        return _coin.SoSFImage_getSubTexture(self, idx, dims, offset)

    def hasSubTextures(self, numsubtextures):
        r"""hasSubTextures(SoSFImage self, int & numsubtextures) -> SbBool"""
        return _coin.SoSFImage_hasSubTextures(self, numsubtextures)

    def setNeverWrite(self, flag):
        r"""setNeverWrite(SoSFImage self, SbBool flag)"""
        return _coin.SoSFImage_setNeverWrite(self, flag)

    def isNeverWrite(self):
        r"""isNeverWrite(SoSFImage self) -> SbBool"""
        return _coin.SoSFImage_isNeverWrite(self)

    def hasTransparency(self):
        r"""hasTransparency(SoSFImage self) -> SbBool"""
        return _coin.SoSFImage_hasTransparency(self)

    def setValue(self, *args):
        r"""
        setValue(SoSFImage self, SbVec2s size, int const nc, unsigned char const * pixels, SoSFImage::CopyPolicy copypolicy=COPY)
        setValue(SoSFImage self, SbVec2s size, int const nc, PyObject * pixels)
        setValue(SoSFImage self, SoSFImage other)
        """
        return _coin.SoSFImage_setValue(self, *args)

# Register SoSFImage in _coin:
_coin.SoSFImage_swigregister(SoSFImage)
class SoSFString(SoSField):
    r"""Proxy of C++ SoSFString class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFString self) -> SoSFString"""
        _coin.SoSFString_swiginit(self, _coin.new_SoSFString())
    __swig_destroy__ = _coin.delete_SoSFString

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFString_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFString_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFString self) -> SoType"""
        return _coin.SoSFString_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFString self, SoField field)"""
        return _coin.SoSFString_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFString self, SoField field) -> SbBool"""
        return _coin.SoSFString_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFString self) -> SbString"""
        return _coin.SoSFString_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFString self, SoSFString field) -> int"""
        return _coin.SoSFString___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFString self, SoSFString field) -> int"""
        return _coin.SoSFString___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFString_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFString self, SbString newvalue)
        setValue(SoSFString self, char const * str)
        setValue(SoSFString self, SoSFString other)
        """
        return _coin.SoSFString_setValue(self, *args)

# Register SoSFString in _coin:
_coin.SoSFString_swigregister(SoSFString)
class SoSFColor(SoSField):
    r"""Proxy of C++ SoSFColor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFColor self) -> SoSFColor"""
        _coin.SoSFColor_swiginit(self, _coin.new_SoSFColor())
    __swig_destroy__ = _coin.delete_SoSFColor

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFColor_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFColor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFColor self) -> SoType"""
        return _coin.SoSFColor_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFColor self, SoField field)"""
        return _coin.SoSFColor_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFColor self, SoField field) -> SbBool"""
        return _coin.SoSFColor_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFColor self) -> SbColor"""
        return _coin.SoSFColor_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFColor self, SoSFColor field) -> int"""
        return _coin.SoSFColor___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFColor self, SoSFColor field) -> int"""
        return _coin.SoSFColor___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFColor_initClass()

    def setHSVValue(self, *args):
        r"""
        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):
        r"""
        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)

# Register SoSFColor in _coin:
_coin.SoSFColor_swigregister(SoSFColor)
class SoReplacedElement(SoElement):
    r"""Proxy of C++ SoReplacedElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoReplacedElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoReplacedElement_getClassStackIndex()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoReplacedElement_initClass()

    def init(self, state):
        r"""init(SoReplacedElement self, SoState state)"""
        return _coin.SoReplacedElement_init(self, state)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoReplacedElement self) -> SoElement"""
        return _coin.SoReplacedElement_copyMatchInfo(self)

    def getNodeId(self):
        r"""getNodeId(SoReplacedElement self) -> uint32_t"""
        return _coin.SoReplacedElement_getNodeId(self)

    def output(self, file):
        r"""output(SoReplacedElement self, FILE * file)"""
        return _coin.SoReplacedElement_output(self, file)

# Register SoReplacedElement in _coin:
_coin.SoReplacedElement_swigregister(SoReplacedElement)
class SbVec3s(object):
    r"""Proxy of C++ SbVec3s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec3s_swiginit(self, _coin.new_SbVec3s(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SbVec3s self) -> short const
        getValue(SbVec3s self)
        """
        return _coin.SbVec3s_getValue(self, *args)

    def dot(self, v):
        r"""dot(SbVec3s self, SbVec3s v) -> int32_t"""
        return _coin.SbVec3s_dot(self, v)

    def negate(self):
        r"""negate(SbVec3s self)"""
        return _coin.SbVec3s_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec3s self, int d) -> SbVec3s
        __imul__(SbVec3s self, double d) -> SbVec3s
        """
        return _coin.SbVec3s___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec3s___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec3s self, SbVec3s v) -> SbVec3s"""
        return _coin.SbVec3s___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec3s self, SbVec3s v) -> SbVec3s"""
        return _coin.SbVec3s___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec3s self) -> SbVec3s"""
        return _coin.SbVec3s___neg__(self)

    def output(self, fp):
        r"""output(SbVec3s self, FILE * fp)"""
        return _coin.SbVec3s_output(self, fp)

    def __add__(self, u):
        r"""__add__(SbVec3s self, SbVec3s u) -> SbVec3s"""
        return _coin.SbVec3s___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbVec3s self, SbVec3s u) -> SbVec3s"""
        return _coin.SbVec3s___sub__(self, u)

    def __mul__(self, d):
        r"""__mul__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___mul__(self, d)

    def __rmul__(self, d):
        r"""__rmul__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___div__(self, d)

    def __truediv__(self, d):
        r"""__truediv__(SbVec3s self, double const d) -> SbVec3s"""
        return _coin.SbVec3s___truediv__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbVec3s self, SbVec3s u) -> int"""
        return _coin.SbVec3s___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbVec3s self, SbVec3s u) -> int"""
        return _coin.SbVec3s___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbVec3s self, int i) -> short"""
        return _coin.SbVec3s___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__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

# Register SbVec3s in _coin:
_coin.SbVec3s_swigregister(SbVec3s)
class SoTextureImageElement(SoReplacedElement):
    r"""Proxy of C++ SoTextureImageElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureImageElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureImageElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureImageElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureImageElement_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):
        r"""init(SoTextureImageElement self, SoState state)"""
        return _coin.SoTextureImageElement_init(self, state)

    @staticmethod
    def setDefault(state, node):
        r"""setDefault(SoState state, SoNode node)"""
        return _coin.SoTextureImageElement_setDefault(state, node)

    @staticmethod
    def set(*args):
        r"""
        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)

    @staticmethod
    def get(*args):
        r"""
        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)

    @staticmethod
    def getBlendColor(state):
        r"""getBlendColor(SoState state) -> SbColor"""
        return _coin.SoTextureImageElement_getBlendColor(state)

    @staticmethod
    def getImage(*args):
        r"""
        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)

    @staticmethod
    def getModel(state):
        r"""getModel(SoState state) -> SoTextureImageElement::Model"""
        return _coin.SoTextureImageElement_getModel(state)

    @staticmethod
    def getWrapS(state):
        r"""getWrapS(SoState state) -> SoTextureImageElement::Wrap"""
        return _coin.SoTextureImageElement_getWrapS(state)

    @staticmethod
    def getWrapT(state):
        r"""getWrapT(SoState state) -> SoTextureImageElement::Wrap"""
        return _coin.SoTextureImageElement_getWrapT(state)

    @staticmethod
    def getWrapR(state):
        r"""getWrapR(SoState state) -> SoTextureImageElement::Wrap"""
        return _coin.SoTextureImageElement_getWrapR(state)

    @staticmethod
    def containsTransparency(state):
        r"""containsTransparency(SoState state) -> SbBool"""
        return _coin.SoTextureImageElement_containsTransparency(state)

    @staticmethod
    def getDefault(*args):
        r"""
        getDefault(SbVec2s size, int & numComponents) -> unsigned char const
        getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
        """
        return _coin.SoTextureImageElement_getDefault(*args)

# Register SoTextureImageElement in _coin:
_coin.SoTextureImageElement_swigregister(SoTextureImageElement)
class SoTexture2(SoTexture):
    r"""Proxy of C++ SoTexture2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture2_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTexture2 self) -> SoType"""
        return _coin.SoTexture2_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTexture2_initClass()

    def __init__(self):
        r"""__init__(SoTexture2 self) -> SoTexture2"""
        _coin.SoTexture2_swiginit(self, _coin.new_SoTexture2())
    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 = property(_coin.SoTexture2_filename_get, _coin.SoTexture2_filename_set, doc=r"""filename : SoSFString""")
    image = property(_coin.SoTexture2_image_get, _coin.SoTexture2_image_set, doc=r"""image : SoSFImage""")
    wrapS = property(_coin.SoTexture2_wrapS_get, _coin.SoTexture2_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoTexture2_wrapT_get, _coin.SoTexture2_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    model = property(_coin.SoTexture2_model_get, _coin.SoTexture2_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoTexture2_blendColor_get, _coin.SoTexture2_blendColor_set, doc=r"""blendColor : SoSFColor""")
    enableCompressedTexture = property(_coin.SoTexture2_enableCompressedTexture_get, _coin.SoTexture2_enableCompressedTexture_set, doc=r"""enableCompressedTexture : SoSFBool""")

    def doAction(self, action):
        r"""doAction(SoTexture2 self, SoAction action)"""
        return _coin.SoTexture2_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTexture2 self, SoGLRenderAction action)"""
        return _coin.SoTexture2_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTexture2 self, SoCallbackAction action)"""
        return _coin.SoTexture2_callback(self, action)

    def rayPick(self, action):
        r"""rayPick(SoTexture2 self, SoRayPickAction action)"""
        return _coin.SoTexture2_rayPick(self, action)

    @staticmethod
    def readImage(fname, w, h, nc, bytes):
        r"""readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
        return _coin.SoTexture2_readImage(fname, w, h, nc, bytes)

# Register SoTexture2 in _coin:
_coin.SoTexture2_swigregister(SoTexture2)
class SoTextureCoordinateBindingElement(SoInt32Element):
    r"""Proxy of C++ SoTextureCoordinateBindingElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateBindingElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureCoordinateBindingElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureCoordinateBindingElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateBindingElement_initClass()
    PER_VERTEX = _coin.SoTextureCoordinateBindingElement_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoTextureCoordinateBindingElement_PER_VERTEX_INDEXED
    

    def init(self, state):
        r"""init(SoTextureCoordinateBindingElement self, SoState state)"""
        return _coin.SoTextureCoordinateBindingElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, SoTextureCoordinateBindingElement::Binding const binding)
        set(SoState state, SoTextureCoordinateBindingElement::Binding const binding)
        """
        return _coin.SoTextureCoordinateBindingElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoTextureCoordinateBindingElement::Binding"""
        return _coin.SoTextureCoordinateBindingElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoTextureCoordinateBindingElement::Binding"""
        return _coin.SoTextureCoordinateBindingElement_getDefault()

# Register SoTextureCoordinateBindingElement in _coin:
_coin.SoTextureCoordinateBindingElement_swigregister(SoTextureCoordinateBindingElement)
class SoTextureCoordinateBinding(SoNode):
    r"""Proxy of C++ SoTextureCoordinateBinding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateBinding_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateBinding self) -> SoType"""
        return _coin.SoTextureCoordinateBinding_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateBinding_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateBinding self) -> SoTextureCoordinateBinding"""
        _coin.SoTextureCoordinateBinding_swiginit(self, _coin.new_SoTextureCoordinateBinding())
    PER_VERTEX = _coin.SoTextureCoordinateBinding_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoTextureCoordinateBinding_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoTextureCoordinateBinding_DEFAULT
    
    value = property(_coin.SoTextureCoordinateBinding_value_get, _coin.SoTextureCoordinateBinding_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateBinding self, SoAction action)"""
        return _coin.SoTextureCoordinateBinding_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateBinding self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateBinding_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateBinding self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateBinding_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateBinding self, SoPickAction action)"""
        return _coin.SoTextureCoordinateBinding_pick(self, action)

# Register SoTextureCoordinateBinding in _coin:
_coin.SoTextureCoordinateBinding_swigregister(SoTextureCoordinateBinding)
class SoTransformation(SoNode):
    r"""Proxy of C++ SoTransformation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransformation self) -> SoType"""
        return _coin.SoTransformation_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransformation_initClass()

# Register SoTransformation in _coin:
_coin.SoTransformation_swigregister(SoTransformation)
class SoUnits(SoTransformation):
    r"""Proxy of C++ SoUnits class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoUnits_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoUnits self) -> SoType"""
        return _coin.SoUnits_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoUnits_initClass()

    def __init__(self):
        r"""__init__(SoUnits self) -> SoUnits"""
        _coin.SoUnits_swiginit(self, _coin.new_SoUnits())
    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 = property(_coin.SoUnits_units_get, _coin.SoUnits_units_set, doc=r"""units : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoUnits self, SoAction action)"""
        return _coin.SoUnits_doAction(self, action)

    def callback(self, action):
        r"""callback(SoUnits self, SoCallbackAction action)"""
        return _coin.SoUnits_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoUnits self, SoGetBoundingBoxAction action)"""
        return _coin.SoUnits_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoUnits self, SoGetMatrixAction action)"""
        return _coin.SoUnits_getMatrix(self, action)

    def GLRender(self, action):
        r"""GLRender(SoUnits self, SoGLRenderAction action)"""
        return _coin.SoUnits_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoUnits self, SoPickAction action)"""
        return _coin.SoUnits_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoUnits self, SoGetPrimitiveCountAction action)"""
        return _coin.SoUnits_getPrimitiveCount(self, action)

# Register SoUnits in _coin:
_coin.SoUnits_swigregister(SoUnits)
class SoCallbackAction(SoAction):
    r"""Proxy of C++ SoCallbackAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoCallbackAction self) -> SoType"""
        return _coin.SoCallbackAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCallbackAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoCallbackAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoCallbackAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCallbackAction_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoCallbackAction self) -> SoCallbackAction
        __init__(SoCallbackAction self, SbViewportRegion vp) -> SoCallbackAction
        """
        _coin.SoCallbackAction_swiginit(self, _coin.new_SoCallbackAction(*args))
    __swig_destroy__ = _coin.delete_SoCallbackAction

    def setViewportRegion(self, vp):
        r"""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):
        r"""getDecimationType(SoCallbackAction self) -> SoDecimationTypeElement::Type"""
        return _coin.SoCallbackAction_getDecimationType(self)

    def getDecimationPercentage(self):
        r"""getDecimationPercentage(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getDecimationPercentage(self)

    def getComplexity(self):
        r"""getComplexity(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getComplexity(self)

    def getComplexityType(self):
        r"""getComplexityType(SoCallbackAction self) -> SoComplexity::Type"""
        return _coin.SoCallbackAction_getComplexityType(self)

    def getNumCoordinates(self):
        r"""getNumCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumCoordinates(self)

    def getCoordinate3(self, index):
        r"""getCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getCoordinate3(self, index)

    def getCoordinate4(self, index):
        r"""getCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"""
        return _coin.SoCallbackAction_getCoordinate4(self, index)

    def getDrawStyle(self):
        r"""getDrawStyle(SoCallbackAction self) -> SoDrawStyle::Style"""
        return _coin.SoCallbackAction_getDrawStyle(self)

    def getLinePattern(self):
        r"""getLinePattern(SoCallbackAction self) -> unsigned short"""
        return _coin.SoCallbackAction_getLinePattern(self)

    def getLineWidth(self):
        r"""getLineWidth(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getLineWidth(self)

    def getPointSize(self):
        r"""getPointSize(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getPointSize(self)

    def getFontName(self):
        r"""getFontName(SoCallbackAction self) -> SbName"""
        return _coin.SoCallbackAction_getFontName(self)

    def getFontSize(self):
        r"""getFontSize(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getFontSize(self)

    def getLightModel(self):
        r"""getLightModel(SoCallbackAction self) -> SoLightModel::Model"""
        return _coin.SoCallbackAction_getLightModel(self)

    def getLightAttenuation(self):
        r"""getLightAttenuation(SoCallbackAction self) -> SbVec3f"""
        return _coin.SoCallbackAction_getLightAttenuation(self)

    def getMaterialBinding(self):
        r"""getMaterialBinding(SoCallbackAction self) -> SoMaterialBinding::Binding"""
        return _coin.SoCallbackAction_getMaterialBinding(self)

    def getNumNormals(self):
        r"""getNumNormals(SoCallbackAction self) -> uint32_t"""
        return _coin.SoCallbackAction_getNumNormals(self)

    def getNormal(self, index):
        r"""getNormal(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getNormal(self, index)

    def getNormalBinding(self):
        r"""getNormalBinding(SoCallbackAction self) -> SoNormalBinding::Binding"""
        return _coin.SoCallbackAction_getNormalBinding(self)

    def getNumProfileCoordinates(self):
        r"""getNumProfileCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumProfileCoordinates(self)

    def getProfileCoordinate2(self, index):
        r"""getProfileCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"""
        return _coin.SoCallbackAction_getProfileCoordinate2(self, index)

    def getProfileCoordinate3(self, index):
        r"""getProfileCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getProfileCoordinate3(self, index)

    def getProfile(self):
        r"""getProfile(SoCallbackAction self) -> SoNodeList"""
        return _coin.SoCallbackAction_getProfile(self)

    def getVertexOrdering(self):
        r"""getVertexOrdering(SoCallbackAction self) -> SoShapeHints::VertexOrdering"""
        return _coin.SoCallbackAction_getVertexOrdering(self)

    def getShapeType(self):
        r"""getShapeType(SoCallbackAction self) -> SoShapeHints::ShapeType"""
        return _coin.SoCallbackAction_getShapeType(self)

    def getFaceType(self):
        r"""getFaceType(SoCallbackAction self) -> SoShapeHints::FaceType"""
        return _coin.SoCallbackAction_getFaceType(self)

    def getCreaseAngle(self):
        r"""getCreaseAngle(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getCreaseAngle(self)

    def getNumTextureCoordinates(self):
        r"""getNumTextureCoordinates(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getNumTextureCoordinates(self)

    def getTextureCoordinate2(self, index):
        r"""getTextureCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"""
        return _coin.SoCallbackAction_getTextureCoordinate2(self, index)

    def getTextureCoordinate3(self, index):
        r"""getTextureCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
        return _coin.SoCallbackAction_getTextureCoordinate3(self, index)

    def getTextureCoordinate4(self, index):
        r"""getTextureCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"""
        return _coin.SoCallbackAction_getTextureCoordinate4(self, index)

    def getTextureCoordinateBinding(self):
        r"""getTextureCoordinateBinding(SoCallbackAction self) -> SoTextureCoordinateBinding::Binding"""
        return _coin.SoCallbackAction_getTextureCoordinateBinding(self)

    def getTextureBlendColor(self):
        r"""getTextureBlendColor(SoCallbackAction self) -> SbColor"""
        return _coin.SoCallbackAction_getTextureBlendColor(self)

    def getTextureImage(self, *args):
        r"""
        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):
        r"""getTextureMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getTextureMatrix(self)

    def getTextureModel(self):
        r"""getTextureModel(SoCallbackAction self) -> SoTexture2::Model"""
        return _coin.SoCallbackAction_getTextureModel(self)

    def getTextureWrapS(self):
        r"""getTextureWrapS(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapS(self)

    def getTextureWrapT(self):
        r"""getTextureWrapT(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapT(self)

    def getTextureWrapR(self):
        r"""getTextureWrapR(SoCallbackAction self) -> SoTexture2::Wrap"""
        return _coin.SoCallbackAction_getTextureWrapR(self)

    def getModelMatrix(self):
        r"""getModelMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getModelMatrix(self)

    def getUnits(self):
        r"""getUnits(SoCallbackAction self) -> SoUnits::Units"""
        return _coin.SoCallbackAction_getUnits(self)

    def getFocalDistance(self):
        r"""getFocalDistance(SoCallbackAction self) -> float"""
        return _coin.SoCallbackAction_getFocalDistance(self)

    def getProjectionMatrix(self):
        r"""getProjectionMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getProjectionMatrix(self)

    def getViewingMatrix(self):
        r"""getViewingMatrix(SoCallbackAction self) -> SbMatrix"""
        return _coin.SoCallbackAction_getViewingMatrix(self)

    def getViewVolume(self):
        r"""getViewVolume(SoCallbackAction self) -> SbViewVolume"""
        return _coin.SoCallbackAction_getViewVolume(self)

    def getViewportRegion(self):
        r"""getViewportRegion(SoCallbackAction self) -> SbViewportRegion"""
        return _coin.SoCallbackAction_getViewportRegion(self)

    def getPickStyle(self):
        r"""getPickStyle(SoCallbackAction self) -> SoPickStyle::Style"""
        return _coin.SoCallbackAction_getPickStyle(self)

    def getSwitch(self):
        r"""getSwitch(SoCallbackAction self) -> int32_t"""
        return _coin.SoCallbackAction_getSwitch(self)

    def getCurrentResponse(self):
        r"""getCurrentResponse(SoCallbackAction self) -> SoCallbackAction::Response"""
        return _coin.SoCallbackAction_getCurrentResponse(self)

    def invokePreCallbacks(self, node):
        r"""invokePreCallbacks(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_invokePreCallbacks(self, node)

    def invokePostCallbacks(self, node):
        r"""invokePostCallbacks(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_invokePostCallbacks(self, node)

    def invokeTriangleCallbacks(self, shape, v1, v2, v3):
        r"""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):
        r"""invokeLineSegmentCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2)"""
        return _coin.SoCallbackAction_invokeLineSegmentCallbacks(self, shape, v1, v2)

    def invokePointCallbacks(self, shape, v):
        r"""invokePointCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v)"""
        return _coin.SoCallbackAction_invokePointCallbacks(self, shape, v)

    def shouldGeneratePrimitives(self, shape):
        r"""shouldGeneratePrimitives(SoCallbackAction self, SoShape shape) -> SbBool"""
        return _coin.SoCallbackAction_shouldGeneratePrimitives(self, shape)

    def getCurPathTail(self):
        r"""getCurPathTail(SoCallbackAction self) -> SoNode"""
        return _coin.SoCallbackAction_getCurPathTail(self)

    def setCurrentNode(self, node):
        r"""setCurrentNode(SoCallbackAction self, SoNode node)"""
        return _coin.SoCallbackAction_setCurrentNode(self, node)

    def setCallbackAll(self, callbackall):
        r"""setCallbackAll(SoCallbackAction self, SbBool callbackall)"""
        return _coin.SoCallbackAction_setCallbackAll(self, callbackall)

    def isCallbackAll(self):
        r"""isCallbackAll(SoCallbackAction self) -> SbBool"""
        return _coin.SoCallbackAction_isCallbackAll(self)

    def getMaterial(self, index=0):
        r"""getMaterial(SoCallbackAction self, int const index=0) -> PyObject"""
        return _coin.SoCallbackAction_getMaterial(self, index)

    def addPreCallback(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""
        addPointCallback(SoCallbackAction self, SoType type, SoPointCB * cb, void * userdata)
        addPointCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoCallbackAction_addPointCallback(self, *args)

# Register SoCallbackAction in _coin:
_coin.SoCallbackAction_swigregister(SoCallbackAction)
class SbVec2f(object):
    r"""Proxy of C++ SbVec2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec2f_swiginit(self, _coin.new_SbVec2f(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""getValue(SbVec2f self)"""
        return _coin.SbVec2f_getValue(self)

    def dot(self, v):
        r"""dot(SbVec2f self, SbVec2f v) -> float"""
        return _coin.SbVec2f_dot(self, v)

    def equals(self, v, tolerance):
        r"""equals(SbVec2f self, SbVec2f v, float tolerance) -> SbBool"""
        return _coin.SbVec2f_equals(self, v, tolerance)

    def length(self):
        r"""length(SbVec2f self) -> float"""
        return _coin.SbVec2f_length(self)

    def sqrLength(self):
        r"""sqrLength(SbVec2f self) -> float"""
        return _coin.SbVec2f_sqrLength(self)

    def negate(self):
        r"""negate(SbVec2f self)"""
        return _coin.SbVec2f_negate(self)

    def normalize(self):
        r"""normalize(SbVec2f self) -> float"""
        return _coin.SbVec2f_normalize(self)

    def __imul__(self, d):
        r"""__imul__(SbVec2f self, float d) -> SbVec2f"""
        return _coin.SbVec2f___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec2f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec2f self, SbVec2f v) -> SbVec2f"""
        return _coin.SbVec2f___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec2f self, SbVec2f v) -> SbVec2f"""
        return _coin.SbVec2f___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec2f self) -> SbVec2f"""
        return _coin.SbVec2f___neg__(self)

    def output(self, fp):
        r"""output(SbVec2f self, FILE * fp)"""
        return _coin.SbVec2f_output(self, fp)

    def __add__(self, u):
        r"""__add__(SbVec2f self, SbVec2f u) -> SbVec2f"""
        return _coin.SbVec2f___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbVec2f self, SbVec2f u) -> SbVec2f"""
        return _coin.SbVec2f___sub__(self, u)

    def __mul__(self, d):
        r"""__mul__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___mul__(self, d)

    def __rmul__(self, d):
        r"""__rmul__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___div__(self, d)

    def __truediv__(self, d):
        r"""__truediv__(SbVec2f self, float const d) -> SbVec2f"""
        return _coin.SbVec2f___truediv__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbVec2f self, SbVec2f u) -> int"""
        return _coin.SbVec2f___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbVec2f self, SbVec2f u) -> int"""
        return _coin.SbVec2f___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbVec2f self, int i) -> float"""
        return _coin.SbVec2f___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__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

# Register SbVec2f in _coin:
_coin.SbVec2f_swigregister(SbVec2f)
class SbViewportRegion(object):
    r"""Proxy of C++ SbViewportRegion class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbViewportRegion self) -> SbViewportRegion
        __init__(SbViewportRegion self, short width, short height) -> SbViewportRegion
        __init__(SbViewportRegion self, SbVec2s winSize) -> SbViewportRegion
        __init__(SbViewportRegion self, SbViewportRegion vpReg) -> SbViewportRegion
        """
        _coin.SbViewportRegion_swiginit(self, _coin.new_SbViewportRegion(*args))

    def setWindowSize(self, *args):
        r"""
        setWindowSize(SbViewportRegion self, short width, short height)
        setWindowSize(SbViewportRegion self, SbVec2s winSize)
        """
        return _coin.SbViewportRegion_setWindowSize(self, *args)

    def setViewport(self, *args):
        r"""
        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):
        r"""
        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):
        r"""getWindowSize(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getWindowSize(self)

    def getViewportOrigin(self):
        r"""getViewportOrigin(SbViewportRegion self) -> SbVec2f"""
        return _coin.SbViewportRegion_getViewportOrigin(self)

    def getViewportOriginPixels(self):
        r"""getViewportOriginPixels(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getViewportOriginPixels(self)

    def getViewportSize(self):
        r"""getViewportSize(SbViewportRegion self) -> SbVec2f"""
        return _coin.SbViewportRegion_getViewportSize(self)

    def getViewportSizePixels(self):
        r"""getViewportSizePixels(SbViewportRegion self) -> SbVec2s"""
        return _coin.SbViewportRegion_getViewportSizePixels(self)

    def getViewportAspectRatio(self):
        r"""getViewportAspectRatio(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getViewportAspectRatio(self)

    def scaleWidth(self, ratio):
        r"""scaleWidth(SbViewportRegion self, float ratio)"""
        return _coin.SbViewportRegion_scaleWidth(self, ratio)

    def scaleHeight(self, ratio):
        r"""scaleHeight(SbViewportRegion self, float ratio)"""
        return _coin.SbViewportRegion_scaleHeight(self, ratio)

    def setPixelsPerInch(self, ppi):
        r"""setPixelsPerInch(SbViewportRegion self, float ppi)"""
        return _coin.SbViewportRegion_setPixelsPerInch(self, ppi)

    def getPixelsPerInch(self):
        r"""getPixelsPerInch(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getPixelsPerInch(self)

    def getPixelsPerPoint(self):
        r"""getPixelsPerPoint(SbViewportRegion self) -> float"""
        return _coin.SbViewportRegion_getPixelsPerPoint(self)

    def output(self, file):
        r"""output(SbViewportRegion self, FILE * file)"""
        return _coin.SbViewportRegion_output(self, file)

    def __eq__(self, u):
        r"""__eq__(SbViewportRegion self, SbViewportRegion u) -> int"""
        return _coin.SbViewportRegion___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbViewportRegion self, SbViewportRegion u) -> int"""
        return _coin.SbViewportRegion___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbViewportRegion

# Register SbViewportRegion in _coin:
_coin.SbViewportRegion_swigregister(SbViewportRegion)
class SoGLRenderAction(SoAction):
    r"""Proxy of C++ SoGLRenderAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoGLRenderAction self) -> SoType"""
        return _coin.SoGLRenderAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLRenderAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGLRenderAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoGLRenderAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLRenderAction_initClass()

    def __init__(self, viewportregion):
        r"""__init__(SoGLRenderAction self, SbViewportRegion viewportregion) -> SoGLRenderAction"""
        _coin.SoGLRenderAction_swiginit(self, _coin.new_SoGLRenderAction(viewportregion))
    __swig_destroy__ = _coin.delete_SoGLRenderAction
    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):
        r"""setViewportRegion(SoGLRenderAction self, SbViewportRegion newregion)"""
        return _coin.SoGLRenderAction_setViewportRegion(self, newregion)

    def getViewportRegion(self):
        r"""getViewportRegion(SoGLRenderAction self) -> SbViewportRegion"""
        return _coin.SoGLRenderAction_getViewportRegion(self)

    def setUpdateArea(self, origin, size):
        r"""setUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLRenderAction_setUpdateArea(self, origin, size)

    def getUpdateArea(self, origin, size):
        r"""getUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLRenderAction_getUpdateArea(self, origin, size)

    def getAbortCallback(self, func_out, userdata_out):
        r"""getAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *& func_out, void *& userdata_out)"""
        return _coin.SoGLRenderAction_getAbortCallback(self, func_out, userdata_out)

    def setTransparencyType(self, type):
        r"""setTransparencyType(SoGLRenderAction self, SoGLRenderAction::TransparencyType const type)"""
        return _coin.SoGLRenderAction_setTransparencyType(self, type)

    def getTransparencyType(self):
        r"""getTransparencyType(SoGLRenderAction self) -> SoGLRenderAction::TransparencyType"""
        return _coin.SoGLRenderAction_getTransparencyType(self)

    def setTransparentDelayedObjectRenderType(self, type):
        r"""setTransparentDelayedObjectRenderType(SoGLRenderAction self, SoGLRenderAction::TransparentDelayedObjectRenderType type)"""
        return _coin.SoGLRenderAction_setTransparentDelayedObjectRenderType(self, type)

    def getTransparentDelayedObjectRenderType(self):
        r"""getTransparentDelayedObjectRenderType(SoGLRenderAction self) -> SoGLRenderAction::TransparentDelayedObjectRenderType"""
        return _coin.SoGLRenderAction_getTransparentDelayedObjectRenderType(self)

    def setSmoothing(self, smooth):
        r"""setSmoothing(SoGLRenderAction self, SbBool const smooth)"""
        return _coin.SoGLRenderAction_setSmoothing(self, smooth)

    def isSmoothing(self):
        r"""isSmoothing(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isSmoothing(self)

    def setNumPasses(self, num):
        r"""setNumPasses(SoGLRenderAction self, int const num)"""
        return _coin.SoGLRenderAction_setNumPasses(self, num)

    def getNumPasses(self):
        r"""getNumPasses(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getNumPasses(self)

    def setPassUpdate(self, flag):
        r"""setPassUpdate(SoGLRenderAction self, SbBool const flag)"""
        return _coin.SoGLRenderAction_setPassUpdate(self, flag)

    def isPassUpdate(self):
        r"""isPassUpdate(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isPassUpdate(self)

    def setCacheContext(self, context):
        r"""setCacheContext(SoGLRenderAction self, uint32_t const context)"""
        return _coin.SoGLRenderAction_setCacheContext(self, context)

    def getCacheContext(self):
        r"""getCacheContext(SoGLRenderAction self) -> uint32_t"""
        return _coin.SoGLRenderAction_getCacheContext(self)

    def addDelayedPath(self, path):
        r"""addDelayedPath(SoGLRenderAction self, SoPath path)"""
        return _coin.SoGLRenderAction_addDelayedPath(self, path)

    def isRenderingDelayedPaths(self):
        r"""isRenderingDelayedPaths(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingDelayedPaths(self)

    def handleTransparency(self, istransparent=0):
        r"""handleTransparency(SoGLRenderAction self, SbBool istransparent=0) -> SbBool"""
        return _coin.SoGLRenderAction_handleTransparency(self, istransparent)

    def setCurPass(self, passnum, numpasses):
        r"""setCurPass(SoGLRenderAction self, int const passnum, int const numpasses)"""
        return _coin.SoGLRenderAction_setCurPass(self, passnum, numpasses)

    def getCurPass(self):
        r"""getCurPass(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getCurPass(self)

    def abortNow(self):
        r"""abortNow(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_abortNow(self)

    def setRenderingIsRemote(self, isremote):
        r"""setRenderingIsRemote(SoGLRenderAction self, SbBool isremote)"""
        return _coin.SoGLRenderAction_setRenderingIsRemote(self, isremote)

    def getRenderingIsRemote(self):
        r"""getRenderingIsRemote(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_getRenderingIsRemote(self)

    def invalidateState(self):
        r"""invalidateState(SoGLRenderAction self)"""
        return _coin.SoGLRenderAction_invalidateState(self)

    def setSortedLayersNumPasses(self, num):
        r"""setSortedLayersNumPasses(SoGLRenderAction self, int num)"""
        return _coin.SoGLRenderAction_setSortedLayersNumPasses(self, num)

    def getSortedLayersNumPasses(self):
        r"""getSortedLayersNumPasses(SoGLRenderAction self) -> int"""
        return _coin.SoGLRenderAction_getSortedLayersNumPasses(self)

    def setSortedObjectOrderStrategy(self, strategy, cb=None, closure=None):
        r"""setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy, SoGLSortedObjectOrderCB * cb=None, void * closure=None)"""
        return _coin.SoGLRenderAction_setSortedObjectOrderStrategy(self, strategy, cb, closure)

    def setDelayedObjDepthWrite(self, write):
        r"""setDelayedObjDepthWrite(SoGLRenderAction self, SbBool write)"""
        return _coin.SoGLRenderAction_setDelayedObjDepthWrite(self, write)

    def getDelayedObjDepthWrite(self):
        r"""getDelayedObjDepthWrite(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_getDelayedObjDepthWrite(self)

    def isRenderingTranspPaths(self):
        r"""isRenderingTranspPaths(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingTranspPaths(self)

    def isRenderingTranspBackfaces(self):
        r"""isRenderingTranspBackfaces(SoGLRenderAction self) -> SbBool"""
        return _coin.SoGLRenderAction_isRenderingTranspBackfaces(self)

    def setPassCallback(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        addPreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)
        addPreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_addPreRenderCallback(self, *args)

    def removePreRenderCallback(self, *args):
        r"""
        removePreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)
        removePreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.SoGLRenderAction_removePreRenderCallback(self, *args)

    @staticmethod
    def constructFromAction(action):
        r"""constructFromAction(SoAction action) -> SoGLRenderAction"""
        return _coin.SoGLRenderAction_constructFromAction(action)

# Register SoGLRenderAction in _coin:
_coin.SoGLRenderAction_swigregister(SoGLRenderAction)
class SoBoxHighlightRenderAction(SoGLRenderAction):
    r"""Proxy of C++ SoBoxHighlightRenderAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoBoxHighlightRenderAction self) -> SoType"""
        return _coin.SoBoxHighlightRenderAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBoxHighlightRenderAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoBoxHighlightRenderAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoBoxHighlightRenderAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBoxHighlightRenderAction_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoBoxHighlightRenderAction self) -> SoBoxHighlightRenderAction
        __init__(SoBoxHighlightRenderAction self, SbViewportRegion viewportregion) -> SoBoxHighlightRenderAction
        """
        _coin.SoBoxHighlightRenderAction_swiginit(self, _coin.new_SoBoxHighlightRenderAction(*args))
    __swig_destroy__ = _coin.delete_SoBoxHighlightRenderAction

    def apply(self, *args):
        r"""
        apply(SoBoxHighlightRenderAction self, SoNode node)
        apply(SoBoxHighlightRenderAction self, SoPath path)
        apply(SoBoxHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoBoxHighlightRenderAction_apply(self, *args)

    def setVisible(self, visible):
        r"""setVisible(SoBoxHighlightRenderAction self, SbBool const visible)"""
        return _coin.SoBoxHighlightRenderAction_setVisible(self, visible)

    def isVisible(self):
        r"""isVisible(SoBoxHighlightRenderAction self) -> SbBool"""
        return _coin.SoBoxHighlightRenderAction_isVisible(self)

    def setColor(self, color):
        r"""setColor(SoBoxHighlightRenderAction self, SbColor color)"""
        return _coin.SoBoxHighlightRenderAction_setColor(self, color)

    def getColor(self):
        r"""getColor(SoBoxHighlightRenderAction self) -> SbColor"""
        return _coin.SoBoxHighlightRenderAction_getColor(self)

    def setLinePattern(self, pattern):
        r"""setLinePattern(SoBoxHighlightRenderAction self, unsigned short pattern)"""
        return _coin.SoBoxHighlightRenderAction_setLinePattern(self, pattern)

    def getLinePattern(self):
        r"""getLinePattern(SoBoxHighlightRenderAction self) -> unsigned short"""
        return _coin.SoBoxHighlightRenderAction_getLinePattern(self)

    def setLineWidth(self, width):
        r"""setLineWidth(SoBoxHighlightRenderAction self, float const width)"""
        return _coin.SoBoxHighlightRenderAction_setLineWidth(self, width)

    def getLineWidth(self):
        r"""getLineWidth(SoBoxHighlightRenderAction self) -> float"""
        return _coin.SoBoxHighlightRenderAction_getLineWidth(self)

# Register SoBoxHighlightRenderAction in _coin:
_coin.SoBoxHighlightRenderAction_swigregister(SoBoxHighlightRenderAction)
class SoLineHighlightRenderAction(SoGLRenderAction):
    r"""Proxy of C++ SoLineHighlightRenderAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoLineHighlightRenderAction self) -> SoType"""
        return _coin.SoLineHighlightRenderAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLineHighlightRenderAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoLineHighlightRenderAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoLineHighlightRenderAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLineHighlightRenderAction_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoLineHighlightRenderAction self) -> SoLineHighlightRenderAction
        __init__(SoLineHighlightRenderAction self, SbViewportRegion viewportregion) -> SoLineHighlightRenderAction
        """
        _coin.SoLineHighlightRenderAction_swiginit(self, _coin.new_SoLineHighlightRenderAction(*args))
    __swig_destroy__ = _coin.delete_SoLineHighlightRenderAction

    def apply(self, *args):
        r"""
        apply(SoLineHighlightRenderAction self, SoNode node)
        apply(SoLineHighlightRenderAction self, SoPath path)
        apply(SoLineHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoLineHighlightRenderAction_apply(self, *args)

    def setVisible(self, visible):
        r"""setVisible(SoLineHighlightRenderAction self, SbBool const visible)"""
        return _coin.SoLineHighlightRenderAction_setVisible(self, visible)

    def isVisible(self):
        r"""isVisible(SoLineHighlightRenderAction self) -> SbBool"""
        return _coin.SoLineHighlightRenderAction_isVisible(self)

    def setColor(self, color):
        r"""setColor(SoLineHighlightRenderAction self, SbColor color)"""
        return _coin.SoLineHighlightRenderAction_setColor(self, color)

    def getColor(self):
        r"""getColor(SoLineHighlightRenderAction self) -> SbColor"""
        return _coin.SoLineHighlightRenderAction_getColor(self)

    def setLinePattern(self, pattern):
        r"""setLinePattern(SoLineHighlightRenderAction self, uint16_t pattern)"""
        return _coin.SoLineHighlightRenderAction_setLinePattern(self, pattern)

    def getLinePattern(self):
        r"""getLinePattern(SoLineHighlightRenderAction self) -> uint16_t"""
        return _coin.SoLineHighlightRenderAction_getLinePattern(self)

    def setLineWidth(self, width):
        r"""setLineWidth(SoLineHighlightRenderAction self, float const width)"""
        return _coin.SoLineHighlightRenderAction_setLineWidth(self, width)

    def getLineWidth(self):
        r"""getLineWidth(SoLineHighlightRenderAction self) -> float"""
        return _coin.SoLineHighlightRenderAction_getLineWidth(self)

# Register SoLineHighlightRenderAction in _coin:
_coin.SoLineHighlightRenderAction_swigregister(SoLineHighlightRenderAction)
class SbBox3f(object):
    r"""Proxy of C++ SbBox3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbBox3f_swiginit(self, _coin.new_SbBox3f(*args))

    def setBounds(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        getMin(SbBox3f self) -> SbVec3f
        getMin(SbBox3f self) -> SbVec3f
        """
        return _coin.SbBox3f_getMin(self, *args)

    def getMax(self, *args):
        r"""
        getMax(SbBox3f self) -> SbVec3f
        getMax(SbBox3f self) -> SbVec3f
        """
        return _coin.SbBox3f_getMax(self, *args)

    def extendBy(self, *args):
        r"""
        extendBy(SbBox3f self, SbVec3f pt)
        extendBy(SbBox3f self, SbBox3f box)
        """
        return _coin.SbBox3f_extendBy(self, *args)

    def transform(self, matrix):
        r"""transform(SbBox3f self, SbMatrix matrix)"""
        return _coin.SbBox3f_transform(self, matrix)

    def makeEmpty(self):
        r"""makeEmpty(SbBox3f self)"""
        return _coin.SbBox3f_makeEmpty(self)

    def isEmpty(self):
        r"""isEmpty(SbBox3f self) -> SbBool"""
        return _coin.SbBox3f_isEmpty(self)

    def hasVolume(self):
        r"""hasVolume(SbBox3f self) -> SbBool"""
        return _coin.SbBox3f_hasVolume(self)

    def getVolume(self):
        r"""getVolume(SbBox3f self) -> float"""
        return _coin.SbBox3f_getVolume(self)

    def intersect(self, *args):
        r"""
        intersect(SbBox3f self, SbVec3f pt) -> SbBool
        intersect(SbBox3f self, SbBox3f box) -> SbBool
        """
        return _coin.SbBox3f_intersect(self, *args)

    def getClosestPoint(self, point):
        r"""getClosestPoint(SbBox3f self, SbVec3f point) -> SbVec3f"""
        return _coin.SbBox3f_getClosestPoint(self, point)

    def outside(self, mvp, cullbits):
        r"""outside(SbBox3f self, SbMatrix mvp, int & cullbits) -> SbBool"""
        return _coin.SbBox3f_outside(self, mvp, cullbits)

    def getCenter(self):
        r"""getCenter(SbBox3f self) -> SbVec3f"""
        return _coin.SbBox3f_getCenter(self)

    def getOrigin(self, originX, originY, originZ):
        r"""getOrigin(SbBox3f self, float & originX, float & originY, float & originZ)"""
        return _coin.SbBox3f_getOrigin(self, originX, originY, originZ)

    def getSize(self, *args):
        r"""
        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):
        r"""getSpan(SbBox3f self, SbVec3f dir, float & dmin, float & dmax)"""
        return _coin.SbBox3f_getSpan(self, dir, dmin, dmax)

    def output(self, file):
        r"""output(SbBox3f self, FILE * file)"""
        return _coin.SbBox3f_output(self, file)

    def __eq__(self, u):
        r"""__eq__(SbBox3f self, SbBox3f u) -> int"""
        return _coin.SbBox3f___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbBox3f self, SbBox3f u) -> int"""
        return _coin.SbBox3f___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbBox3f

# Register SbBox3f in _coin:
_coin.SbBox3f_swigregister(SbBox3f)
class SbMatrix(object):
    r"""Proxy of C++ SbMatrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbMatrix_swiginit(self, _coin.new_SbMatrix(*args))
    __swig_destroy__ = _coin.delete_SbMatrix

    def setValue(self, *args):
        r"""
        setValue(SbMatrix self, SbMat const & m)
        setValue(SbMatrix self, SbDPMatrix m)
        """
        return _coin.SbMatrix_setValue(self, *args)

    def makeIdentity(self):
        r"""makeIdentity(SbMatrix self)"""
        return _coin.SbMatrix_makeIdentity(self)

    def setRotate(self, q):
        r"""setRotate(SbMatrix self, SbRotation q)"""
        return _coin.SbMatrix_setRotate(self, q)

    def inverse(self):
        r"""inverse(SbMatrix self) -> SbMatrix"""
        return _coin.SbMatrix_inverse(self)

    def det3(self, *args):
        r"""
        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):
        r"""det4(SbMatrix self) -> float"""
        return _coin.SbMatrix_det4(self)

    def equals(self, m, tolerance):
        r"""equals(SbMatrix self, SbMatrix m, float tolerance) -> SbBool"""
        return _coin.SbMatrix_equals(self, m, tolerance)

    def __imul__(self, m):
        r"""__imul__(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix___imul__(self, m)

    def getValue(self, *args):
        r"""
        getValue(SbMatrix self) -> SbMat const
        getValue(SbMatrix self, SbMat & m)
        """
        return _coin.SbMatrix_getValue(self, *args)

    @staticmethod
    def identity():
        r"""identity() -> SbMatrix"""
        return _coin.SbMatrix_identity()

    def setScale(self, *args):
        r"""
        setScale(SbMatrix self, float const s)
        setScale(SbMatrix self, SbVec3f s)
        """
        return _coin.SbMatrix_setScale(self, *args)

    def setTranslate(self, t):
        r"""setTranslate(SbMatrix self, SbVec3f t)"""
        return _coin.SbMatrix_setTranslate(self, t)

    def setTransform(self, *args):
        r"""
        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):
        r"""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):
        r"""LUDecomposition(SbMatrix self, int [4] index, float & d) -> SbBool"""
        return _coin.SbMatrix_LUDecomposition(self, index, d)

    def LUBackSubstitution(self, index, b):
        r"""LUBackSubstitution(SbMatrix self, int [4] index, float [4] b)"""
        return _coin.SbMatrix_LUBackSubstitution(self, index, b)

    def transpose(self):
        r"""transpose(SbMatrix self) -> SbMatrix"""
        return _coin.SbMatrix_transpose(self)

    def multRight(self, m):
        r"""multRight(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix_multRight(self, m)

    def multLeft(self, m):
        r"""multLeft(SbMatrix self, SbMatrix m) -> SbMatrix"""
        return _coin.SbMatrix_multLeft(self, m)

    def multMatrixVec(self, src):
        r"""multMatrixVec(SbMatrix self, SbVec3f src)"""
        return _coin.SbMatrix_multMatrixVec(self, src)

    def multDirMatrix(self, src):
        r"""multDirMatrix(SbMatrix self, SbVec3f src)"""
        return _coin.SbMatrix_multDirMatrix(self, src)

    def multLineMatrix(self, src, dst):
        r"""multLineMatrix(SbMatrix self, SbLine src, SbLine dst)"""
        return _coin.SbMatrix_multLineMatrix(self, src, dst)

    def multVecMatrix(self, *args):
        r"""
        multVecMatrix(SbMatrix self, SbVec3f src)
        multVecMatrix(SbMatrix self, SbVec4f src)
        """
        return _coin.SbMatrix_multVecMatrix(self, *args)

    def output(self, fp):
        r"""output(SbMatrix self, FILE * fp)"""
        return _coin.SbMatrix_output(self, fp)

    def getTransform(self, *args):
        r"""
        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):
        r"""
        __mul__(SbMatrix self, SbMatrix u) -> SbMatrix
        __mul__(SbMatrix self, SbVec3f u) -> SbVec3f
        """
        return _coin.SbMatrix___mul__(self, *args)

    def __rmul__(self, u):
        r"""__rmul__(SbMatrix self, SbVec3f u) -> SbVec3f"""
        return _coin.SbMatrix___rmul__(self, u)

    def __eq__(self, u):
        r"""__eq__(SbMatrix self, SbMatrix u) -> int"""
        return _coin.SbMatrix___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbMatrix self, SbMatrix u) -> int"""
        return _coin.SbMatrix___ne__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbMatrix self, int i) -> float const *"""
        return _coin.SbMatrix___getitem__(self, i)

# Register SbMatrix in _coin:
_coin.SbMatrix_swigregister(SbMatrix)
class SbXfBox3f(SbBox3f):
    r"""Proxy of C++ SbXfBox3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbXfBox3f self) -> SbXfBox3f
        __init__(SbXfBox3f self, SbVec3f boxmin, SbVec3f boxmax) -> SbXfBox3f
        __init__(SbXfBox3f self, SbBox3f box) -> SbXfBox3f
        """
        _coin.SbXfBox3f_swiginit(self, _coin.new_SbXfBox3f(*args))
    __swig_destroy__ = _coin.delete_SbXfBox3f

    def setTransform(self, m):
        r"""setTransform(SbXfBox3f self, SbMatrix m)"""
        return _coin.SbXfBox3f_setTransform(self, m)

    def getTransform(self):
        r"""getTransform(SbXfBox3f self) -> SbMatrix"""
        return _coin.SbXfBox3f_getTransform(self)

    def getInverse(self):
        r"""getInverse(SbXfBox3f self) -> SbMatrix"""
        return _coin.SbXfBox3f_getInverse(self)

    def getCenter(self):
        r"""getCenter(SbXfBox3f self) -> SbVec3f"""
        return _coin.SbXfBox3f_getCenter(self)

    def extendBy(self, *args):
        r"""
        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):
        r"""
        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):
        r"""getSpan(SbXfBox3f self, SbVec3f direction, float & dMin, float & dMax)"""
        return _coin.SbXfBox3f_getSpan(self, direction, dMin, dMax)

    def project(self):
        r"""project(SbXfBox3f self) -> SbBox3f"""
        return _coin.SbXfBox3f_project(self)

    def transform(self, m):
        r"""transform(SbXfBox3f self, SbMatrix m)"""
        return _coin.SbXfBox3f_transform(self, m)

    def getVolume(self):
        r"""getVolume(SbXfBox3f self) -> float"""
        return _coin.SbXfBox3f_getVolume(self)

    def output(self, file):
        r"""output(SbXfBox3f self, FILE * file)"""
        return _coin.SbXfBox3f_output(self, file)

    def __eq__(self, u):
        r"""__eq__(SbXfBox3f self, SbXfBox3f u) -> int"""
        return _coin.SbXfBox3f___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbXfBox3f self, SbXfBox3f u) -> int"""
        return _coin.SbXfBox3f___ne__(self, u)

# Register SbXfBox3f in _coin:
_coin.SbXfBox3f_swigregister(SbXfBox3f)
class SoGetBoundingBoxAction(SoAction):
    r"""Proxy of C++ SoGetBoundingBoxAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoGetBoundingBoxAction self) -> SoType"""
        return _coin.SoGetBoundingBoxAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGetBoundingBoxAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetBoundingBoxAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetBoundingBoxAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGetBoundingBoxAction_initClass()

    def __init__(self, vp):
        r"""__init__(SoGetBoundingBoxAction self, SbViewportRegion vp) -> SoGetBoundingBoxAction"""
        _coin.SoGetBoundingBoxAction_swiginit(self, _coin.new_SoGetBoundingBoxAction(vp))
    __swig_destroy__ = _coin.delete_SoGetBoundingBoxAction
    TRANSFORM = _coin.SoGetBoundingBoxAction_TRANSFORM
    
    BBOX = _coin.SoGetBoundingBoxAction_BBOX
    
    ALL = _coin.SoGetBoundingBoxAction_ALL
    

    def setViewportRegion(self, newregion):
        r"""setViewportRegion(SoGetBoundingBoxAction self, SbViewportRegion newregion)"""
        return _coin.SoGetBoundingBoxAction_setViewportRegion(self, newregion)

    def getViewportRegion(self):
        r"""getViewportRegion(SoGetBoundingBoxAction self) -> SbViewportRegion"""
        return _coin.SoGetBoundingBoxAction_getViewportRegion(self)

    def getBoundingBox(self):
        r"""getBoundingBox(SoGetBoundingBoxAction self) -> SbBox3f"""
        return _coin.SoGetBoundingBoxAction_getBoundingBox(self)

    def getXfBoundingBox(self):
        r"""getXfBoundingBox(SoGetBoundingBoxAction self) -> SbXfBox3f"""
        return _coin.SoGetBoundingBoxAction_getXfBoundingBox(self)

    def getCenter(self):
        r"""getCenter(SoGetBoundingBoxAction self) -> SbVec3f"""
        return _coin.SoGetBoundingBoxAction_getCenter(self)

    def setInCameraSpace(self, flag):
        r"""setInCameraSpace(SoGetBoundingBoxAction self, SbBool const flag)"""
        return _coin.SoGetBoundingBoxAction_setInCameraSpace(self, flag)

    def isInCameraSpace(self):
        r"""isInCameraSpace(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isInCameraSpace(self)

    def setResetPath(self, *args):
        r"""setResetPath(SoGetBoundingBoxAction self, SoPath path, SbBool const resetbefore=1, SoGetBoundingBoxAction::ResetType const what=ALL)"""
        return _coin.SoGetBoundingBoxAction_setResetPath(self, *args)

    def getResetPath(self):
        r"""getResetPath(SoGetBoundingBoxAction self) -> SoPath"""
        return _coin.SoGetBoundingBoxAction_getResetPath(self)

    def isResetPath(self):
        r"""isResetPath(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isResetPath(self)

    def isResetBefore(self):
        r"""isResetBefore(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isResetBefore(self)

    def getWhatReset(self):
        r"""getWhatReset(SoGetBoundingBoxAction self) -> SoGetBoundingBoxAction::ResetType"""
        return _coin.SoGetBoundingBoxAction_getWhatReset(self)

    def checkResetBefore(self):
        r"""checkResetBefore(SoGetBoundingBoxAction self)"""
        return _coin.SoGetBoundingBoxAction_checkResetBefore(self)

    def checkResetAfter(self):
        r"""checkResetAfter(SoGetBoundingBoxAction self)"""
        return _coin.SoGetBoundingBoxAction_checkResetAfter(self)

    def extendBy(self, *args):
        r"""
        extendBy(SoGetBoundingBoxAction self, SbBox3f box)
        extendBy(SoGetBoundingBoxAction self, SbXfBox3f box)
        """
        return _coin.SoGetBoundingBoxAction_extendBy(self, *args)

    def setCenter(self, center, transformcenter):
        r"""setCenter(SoGetBoundingBoxAction self, SbVec3f center, SbBool const transformcenter)"""
        return _coin.SoGetBoundingBoxAction_setCenter(self, center, transformcenter)

    def isCenterSet(self):
        r"""isCenterSet(SoGetBoundingBoxAction self) -> SbBool"""
        return _coin.SoGetBoundingBoxAction_isCenterSet(self)

    def resetCenter(self):
        r"""resetCenter(SoGetBoundingBoxAction self)"""
        return _coin.SoGetBoundingBoxAction_resetCenter(self)

# Register SoGetBoundingBoxAction in _coin:
_coin.SoGetBoundingBoxAction_swigregister(SoGetBoundingBoxAction)
class SbVec4f(object):
    r"""Proxy of C++ SbVec4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec4f_swiginit(self, _coin.new_SbVec4f(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""getValue(SbVec4f self) -> float const *"""
        return _coin.SbVec4f_getValue(self)

    def equals(self, v, tolerance):
        r"""equals(SbVec4f self, SbVec4f v, float tolerance) -> SbBool"""
        return _coin.SbVec4f_equals(self, v, tolerance)

    def dot(self, v):
        r"""dot(SbVec4f self, SbVec4f v) -> float"""
        return _coin.SbVec4f_dot(self, v)

    def getReal(self, v):
        r"""getReal(SbVec4f self, SbVec3f v)"""
        return _coin.SbVec4f_getReal(self, v)

    def length(self):
        r"""length(SbVec4f self) -> float"""
        return _coin.SbVec4f_length(self)

    def sqrLength(self):
        r"""sqrLength(SbVec4f self) -> float"""
        return _coin.SbVec4f_sqrLength(self)

    def negate(self):
        r"""negate(SbVec4f self)"""
        return _coin.SbVec4f_negate(self)

    def normalize(self):
        r"""normalize(SbVec4f self) -> float"""
        return _coin.SbVec4f_normalize(self)

    def __imul__(self, d):
        r"""__imul__(SbVec4f self, float d) -> SbVec4f"""
        return _coin.SbVec4f___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec4f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec4f self, SbVec4f v) -> SbVec4f"""
        return _coin.SbVec4f___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec4f self, SbVec4f v) -> SbVec4f"""
        return _coin.SbVec4f___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec4f self) -> SbVec4f"""
        return _coin.SbVec4f___neg__(self)

    def output(self, fp):
        r"""output(SbVec4f self, FILE * fp)"""
        return _coin.SbVec4f_output(self, fp)

    def __add__(self, u):
        r"""__add__(SbVec4f self, SbVec4f u) -> SbVec4f"""
        return _coin.SbVec4f___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbVec4f self, SbVec4f u) -> SbVec4f"""
        return _coin.SbVec4f___sub__(self, u)

    def __mul__(self, *args):
        r"""
        __mul__(SbVec4f self, float const d) -> SbVec4f
        __mul__(SbVec4f self, SbMatrix m) -> SbVec4f
        """
        return _coin.SbVec4f___mul__(self, *args)

    def __rmul__(self, d):
        r"""__rmul__(SbVec4f self, float const d) -> SbVec4f"""
        return _coin.SbVec4f___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbVec4f self, float const d) -> SbVec4f"""
        return _coin.SbVec4f___div__(self, d)

    def __truediv__(self, d):
        r"""__truediv__(SbVec4f self, float const d) -> SbVec4f"""
        return _coin.SbVec4f___truediv__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbVec4f self, SbVec4f u) -> int"""
        return _coin.SbVec4f___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbVec4f self, SbVec4f u) -> int"""
        return _coin.SbVec4f___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbVec4f self, int i) -> float"""
        return _coin.SbVec4f___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__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

# Register SbVec4f in _coin:
_coin.SbVec4f_swigregister(SbVec4f)
class SbRotation(object):
    r"""Proxy of C++ SbRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbRotation_swiginit(self, _coin.new_SbRotation(*args))

    def getValue(self):
        r"""getValue(SbRotation self) -> float const *"""
        return _coin.SbRotation_getValue(self)

    def getAxisAngle(self):
        r"""getAxisAngle(SbRotation self)"""
        return _coin.SbRotation_getAxisAngle(self)

    def getMatrix(self):
        r"""getMatrix(SbRotation self)"""
        return _coin.SbRotation_getMatrix(self)

    def invert(self):
        r"""invert(SbRotation self) -> SbRotation"""
        return _coin.SbRotation_invert(self)

    def inverse(self):
        r"""inverse(SbRotation self) -> SbRotation"""
        return _coin.SbRotation_inverse(self)

    def setValue(self, *args):
        r"""
        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):
        r"""
        __imul__(SbRotation self, SbRotation q) -> SbRotation
        __imul__(SbRotation self, float const s) -> SbRotation
        """
        return _coin.SbRotation___imul__(self, *args)

    def equals(self, r, tolerance):
        r"""equals(SbRotation self, SbRotation r, float const tolerance) -> SbBool"""
        return _coin.SbRotation_equals(self, r, tolerance)

    def multVec(self, src):
        r"""multVec(SbRotation self, SbVec3f src)"""
        return _coin.SbRotation_multVec(self, src)

    def scaleAngle(self, scaleFactor):
        r"""scaleAngle(SbRotation self, float const scaleFactor)"""
        return _coin.SbRotation_scaleAngle(self, scaleFactor)

    @staticmethod
    def slerp(rot0, rot1, t):
        r"""slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
        return _coin.SbRotation_slerp(rot0, rot1, t)

    @staticmethod
    def identity():
        r"""identity() -> SbRotation"""
        return _coin.SbRotation_identity()

    def output(self, fp):
        r"""output(SbRotation self, FILE * fp)"""
        return _coin.SbRotation_output(self, fp)

    def __mul__(self, *args):
        r"""
        __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):
        r"""__eq__(SbRotation self, SbRotation u) -> int"""
        return _coin.SbRotation___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbRotation self, SbRotation u) -> int"""
        return _coin.SbRotation___nq__(self, u)

    def __imul__(self, other):
        return self * other

    __swig_destroy__ = _coin.delete_SbRotation

# Register SbRotation in _coin:
_coin.SbRotation_swigregister(SbRotation)
class SoGetMatrixAction(SoAction):
    r"""Proxy of C++ SoGetMatrixAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoGetMatrixAction self) -> SoType"""
        return _coin.SoGetMatrixAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGetMatrixAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetMatrixAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetMatrixAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGetMatrixAction_initClass()

    def __init__(self, region):
        r"""__init__(SoGetMatrixAction self, SbViewportRegion region) -> SoGetMatrixAction"""
        _coin.SoGetMatrixAction_swiginit(self, _coin.new_SoGetMatrixAction(region))
    __swig_destroy__ = _coin.delete_SoGetMatrixAction

    def setViewportRegion(self, region):
        r"""setViewportRegion(SoGetMatrixAction self, SbViewportRegion region)"""
        return _coin.SoGetMatrixAction_setViewportRegion(self, region)

    def getViewportRegion(self):
        r"""getViewportRegion(SoGetMatrixAction self) -> SbViewportRegion"""
        return _coin.SoGetMatrixAction_getViewportRegion(self)

    def getMatrix(self):
        r"""getMatrix(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getMatrix(self)

    def getInverse(self):
        r"""getInverse(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getInverse(self)

    def getTextureMatrix(self):
        r"""getTextureMatrix(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getTextureMatrix(self)

    def getTextureInverse(self):
        r"""getTextureInverse(SoGetMatrixAction self) -> SbMatrix"""
        return _coin.SoGetMatrixAction_getTextureInverse(self)

# Register SoGetMatrixAction in _coin:
_coin.SoGetMatrixAction_swigregister(SoGetMatrixAction)
class SoGetPrimitiveCountAction(SoAction):
    r"""Proxy of C++ SoGetPrimitiveCountAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoGetPrimitiveCountAction self) -> SoType"""
        return _coin.SoGetPrimitiveCountAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGetPrimitiveCountAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoGetPrimitiveCountAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoGetPrimitiveCountAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGetPrimitiveCountAction_initClass()

    def __init__(self):
        r"""__init__(SoGetPrimitiveCountAction self) -> SoGetPrimitiveCountAction"""
        _coin.SoGetPrimitiveCountAction_swiginit(self, _coin.new_SoGetPrimitiveCountAction())
    __swig_destroy__ = _coin.delete_SoGetPrimitiveCountAction

    def getTriangleCount(self):
        r"""getTriangleCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getTriangleCount(self)

    def getLineCount(self):
        r"""getLineCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getLineCount(self)

    def getPointCount(self):
        r"""getPointCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getPointCount(self)

    def getTextCount(self):
        r"""getTextCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getTextCount(self)

    def getImageCount(self):
        r"""getImageCount(SoGetPrimitiveCountAction self) -> int"""
        return _coin.SoGetPrimitiveCountAction_getImageCount(self)

    def containsNoPrimitives(self):
        r"""containsNoPrimitives(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_containsNoPrimitives(self)

    def containsNonTriangleShapes(self):
        r"""containsNonTriangleShapes(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_containsNonTriangleShapes(self)

    def is3DTextCountedAsTriangles(self):
        r"""is3DTextCountedAsTriangles(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_is3DTextCountedAsTriangles(self)

    def setCount3DTextAsTriangles(self, flag):
        r"""setCount3DTextAsTriangles(SoGetPrimitiveCountAction self, SbBool const flag)"""
        return _coin.SoGetPrimitiveCountAction_setCount3DTextAsTriangles(self, flag)

    def canApproximateCount(self):
        r"""canApproximateCount(SoGetPrimitiveCountAction self) -> SbBool"""
        return _coin.SoGetPrimitiveCountAction_canApproximateCount(self)

    def setCanApproximate(self, flag):
        r"""setCanApproximate(SoGetPrimitiveCountAction self, SbBool const flag)"""
        return _coin.SoGetPrimitiveCountAction_setCanApproximate(self, flag)

    def setDecimationValue(self, type, percentage=1.0):
        r"""setDecimationValue(SoGetPrimitiveCountAction self, SoDecimationTypeElement::Type type, float percentage=1.0)"""
        return _coin.SoGetPrimitiveCountAction_setDecimationValue(self, type, percentage)

    def getDecimationType(self):
        r"""getDecimationType(SoGetPrimitiveCountAction self) -> SoDecimationTypeElement::Type"""
        return _coin.SoGetPrimitiveCountAction_getDecimationType(self)

    def getDecimationPercentage(self):
        r"""getDecimationPercentage(SoGetPrimitiveCountAction self) -> float"""
        return _coin.SoGetPrimitiveCountAction_getDecimationPercentage(self)

    def addNumTriangles(self, num):
        r"""addNumTriangles(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumTriangles(self, num)

    def addNumLines(self, num):
        r"""addNumLines(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumLines(self, num)

    def addNumPoints(self, num):
        r"""addNumPoints(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumPoints(self, num)

    def addNumText(self, num):
        r"""addNumText(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumText(self, num)

    def addNumImage(self, num):
        r"""addNumImage(SoGetPrimitiveCountAction self, int const num)"""
        return _coin.SoGetPrimitiveCountAction_addNumImage(self, num)

    def incNumTriangles(self):
        r"""incNumTriangles(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumTriangles(self)

    def incNumLines(self):
        r"""incNumLines(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumLines(self)

    def incNumPoints(self):
        r"""incNumPoints(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumPoints(self)

    def incNumText(self):
        r"""incNumText(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumText(self)

    def incNumImage(self):
        r"""incNumImage(SoGetPrimitiveCountAction self)"""
        return _coin.SoGetPrimitiveCountAction_incNumImage(self)

# Register SoGetPrimitiveCountAction in _coin:
_coin.SoGetPrimitiveCountAction_swigregister(SoGetPrimitiveCountAction)
class SoHandleEventAction(SoAction):
    r"""Proxy of C++ SoHandleEventAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoHandleEventAction self) -> SoType"""
        return _coin.SoHandleEventAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoHandleEventAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoHandleEventAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoHandleEventAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoHandleEventAction_initClass()

    def __init__(self, viewportregion):
        r"""__init__(SoHandleEventAction self, SbViewportRegion viewportregion) -> SoHandleEventAction"""
        _coin.SoHandleEventAction_swiginit(self, _coin.new_SoHandleEventAction(viewportregion))
    __swig_destroy__ = _coin.delete_SoHandleEventAction

    def setViewportRegion(self, newregion):
        r"""setViewportRegion(SoHandleEventAction self, SbViewportRegion newregion)"""
        return _coin.SoHandleEventAction_setViewportRegion(self, newregion)

    def getViewportRegion(self):
        r"""getViewportRegion(SoHandleEventAction self) -> SbViewportRegion"""
        return _coin.SoHandleEventAction_getViewportRegion(self)

    def setEvent(self, ev):
        r"""setEvent(SoHandleEventAction self, SoEvent ev)"""
        return _coin.SoHandleEventAction_setEvent(self, ev)

    def getEvent(self):
        r"""getEvent(SoHandleEventAction self) -> SoEvent"""
        return _coin.SoHandleEventAction_getEvent(self)

    def setHandled(self):
        r"""setHandled(SoHandleEventAction self)"""
        return _coin.SoHandleEventAction_setHandled(self)

    def isHandled(self):
        r"""isHandled(SoHandleEventAction self) -> SbBool"""
        return _coin.SoHandleEventAction_isHandled(self)

    def setGrabber(self, node):
        r"""setGrabber(SoHandleEventAction self, SoNode node)"""
        return _coin.SoHandleEventAction_setGrabber(self, node)

    def releaseGrabber(self):
        r"""releaseGrabber(SoHandleEventAction self)"""
        return _coin.SoHandleEventAction_releaseGrabber(self)

    def getGrabber(self):
        r"""getGrabber(SoHandleEventAction self) -> SoNode"""
        return _coin.SoHandleEventAction_getGrabber(self)

    def setPickRoot(self, node):
        r"""setPickRoot(SoHandleEventAction self, SoNode node)"""
        return _coin.SoHandleEventAction_setPickRoot(self, node)

    def getPickRoot(self):
        r"""getPickRoot(SoHandleEventAction self) -> SoNode"""
        return _coin.SoHandleEventAction_getPickRoot(self)

    def setPickRadius(self, radiusinpixels):
        r"""setPickRadius(SoHandleEventAction self, float const radiusinpixels)"""
        return _coin.SoHandleEventAction_setPickRadius(self, radiusinpixels)

    def getPickedPoint(self):
        r"""getPickedPoint(SoHandleEventAction self) -> SoPickedPoint"""
        return _coin.SoHandleEventAction_getPickedPoint(self)

    def getPickedPointList(self):
        r"""getPickedPointList(SoHandleEventAction self) -> SoPickedPointList"""
        return _coin.SoHandleEventAction_getPickedPointList(self)

# Register SoHandleEventAction in _coin:
_coin.SoHandleEventAction_swigregister(SoHandleEventAction)
class SoPickAction(SoAction):
    r"""Proxy of C++ SoPickAction class."""

    thisown = property(lambda x: x.this.own(), lambda 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):
        r"""getTypeId(SoPickAction self) -> SoType"""
        return _coin.SoPickAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPickAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoPickAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoPickAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPickAction_initClass()

    def setViewportRegion(self, newregion):
        r"""setViewportRegion(SoPickAction self, SbViewportRegion newregion)"""
        return _coin.SoPickAction_setViewportRegion(self, newregion)

    def getViewportRegion(self):
        r"""getViewportRegion(SoPickAction self) -> SbViewportRegion"""
        return _coin.SoPickAction_getViewportRegion(self)

    def enableCulling(self, flag):
        r"""enableCulling(SoPickAction self, SbBool const flag)"""
        return _coin.SoPickAction_enableCulling(self, flag)

    def isCullingEnabled(self):
        r"""isCullingEnabled(SoPickAction self) -> SbBool"""
        return _coin.SoPickAction_isCullingEnabled(self)

# Register SoPickAction in _coin:
_coin.SoPickAction_swigregister(SoPickAction)
class SoRayPickAction(SoPickAction):
    r"""Proxy of C++ SoRayPickAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoRayPickAction self) -> SoType"""
        return _coin.SoRayPickAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRayPickAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoRayPickAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoRayPickAction_enableElement(type, stackindex)

    def __init__(self, viewportregion):
        r"""__init__(SoRayPickAction self, SbViewportRegion viewportregion) -> SoRayPickAction"""
        _coin.SoRayPickAction_swiginit(self, _coin.new_SoRayPickAction(viewportregion))
    __swig_destroy__ = _coin.delete_SoRayPickAction

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoRayPickAction_initClass()

    def setPoint(self, viewportPoint):
        r"""setPoint(SoRayPickAction self, SbVec2s viewportPoint)"""
        return _coin.SoRayPickAction_setPoint(self, viewportPoint)

    def setNormalizedPoint(self, normpoint):
        r"""setNormalizedPoint(SoRayPickAction self, SbVec2f normpoint)"""
        return _coin.SoRayPickAction_setNormalizedPoint(self, normpoint)

    def setRadius(self, radiusinpixels):
        r"""setRadius(SoRayPickAction self, float const radiusinpixels)"""
        return _coin.SoRayPickAction_setRadius(self, radiusinpixels)

    def setRay(self, start, direction, neardistance=-1.0, fardistance=-1.0):
        r"""setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction, float neardistance=-1.0, float fardistance=-1.0)"""
        return _coin.SoRayPickAction_setRay(self, start, direction, neardistance, fardistance)

    def setPickAll(self, flag):
        r"""setPickAll(SoRayPickAction self, SbBool const flag)"""
        return _coin.SoRayPickAction_setPickAll(self, flag)

    def isPickAll(self):
        r"""isPickAll(SoRayPickAction self) -> SbBool"""
        return _coin.SoRayPickAction_isPickAll(self)

    def getPickedPointList(self):
        r"""getPickedPointList(SoRayPickAction self) -> SoPickedPointList"""
        return _coin.SoRayPickAction_getPickedPointList(self)

    def getPickedPoint(self, index=0):
        r"""getPickedPoint(SoRayPickAction self, int const index=0) -> SoPickedPoint"""
        return _coin.SoRayPickAction_getPickedPoint(self, index)

    def computeWorldSpaceRay(self):
        r"""computeWorldSpaceRay(SoRayPickAction self)"""
        return _coin.SoRayPickAction_computeWorldSpaceRay(self)

    def hasWorldSpaceRay(self):
        r"""hasWorldSpaceRay(SoRayPickAction self) -> SbBool"""
        return _coin.SoRayPickAction_hasWorldSpaceRay(self)

    def setObjectSpace(self, *args):
        r"""
        setObjectSpace(SoRayPickAction self)
        setObjectSpace(SoRayPickAction self)
        """
        return _coin.SoRayPickAction_setObjectSpace(self, *args)

    def intersect(self, *args):
        r"""
        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, SbVec3f intersection, SbBool const usefullviewvolume=1) -> SbBool
        """
        return _coin.SoRayPickAction_intersect(self, *args)

    def getViewVolume(self):
        r"""getViewVolume(SoRayPickAction self) -> SbViewVolume"""
        return _coin.SoRayPickAction_getViewVolume(self)

    def getLine(self):
        r"""getLine(SoRayPickAction self) -> SbLine"""
        return _coin.SoRayPickAction_getLine(self)

    def isBetweenPlanes(self, intersection):
        r"""isBetweenPlanes(SoRayPickAction self, SbVec3f intersection) -> SbBool"""
        return _coin.SoRayPickAction_isBetweenPlanes(self, intersection)

    def addIntersection(self, objectspacepoint, frontpick=1):
        r"""addIntersection(SoRayPickAction self, SbVec3f objectspacepoint, SbBool frontpick=1) -> SoPickedPoint"""
        return _coin.SoRayPickAction_addIntersection(self, objectspacepoint, frontpick)

    def reset(self):
        r"""reset(SoRayPickAction self)"""
        return _coin.SoRayPickAction_reset(self)

# Register SoRayPickAction in _coin:
_coin.SoRayPickAction_swigregister(SoRayPickAction)
class SoSearchAction(SoAction):
    r"""Proxy of C++ SoSearchAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoSearchAction self) -> SoType"""
        return _coin.SoSearchAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSearchAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoSearchAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoSearchAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSearchAction_initClass()

    def __init__(self):
        r"""__init__(SoSearchAction self) -> SoSearchAction"""
        _coin.SoSearchAction_swiginit(self, _coin.new_SoSearchAction())
    __swig_destroy__ = _coin.delete_SoSearchAction
    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):
        r"""setNode(SoSearchAction self, SoNode node)"""
        return _coin.SoSearchAction_setNode(self, node)

    def getNode(self):
        r"""getNode(SoSearchAction self) -> SoNode"""
        return _coin.SoSearchAction_getNode(self)

    def setType(self, type, chkderived=1):
        r"""setType(SoSearchAction self, SoType type, SbBool const chkderived=1)"""
        return _coin.SoSearchAction_setType(self, type, chkderived)

    def getType(self, chkderived):
        r"""getType(SoSearchAction self, SbBool & chkderived) -> SoType"""
        return _coin.SoSearchAction_getType(self, chkderived)

    def setName(self, name):
        r"""setName(SoSearchAction self, SbName name)"""
        return _coin.SoSearchAction_setName(self, name)

    def getName(self):
        r"""getName(SoSearchAction self) -> SbName"""
        return _coin.SoSearchAction_getName(self)

    def setFind(self, what):
        r"""setFind(SoSearchAction self, int const what)"""
        return _coin.SoSearchAction_setFind(self, what)

    def getFind(self):
        r"""getFind(SoSearchAction self) -> int"""
        return _coin.SoSearchAction_getFind(self)

    def setInterest(self, interest):
        r"""setInterest(SoSearchAction self, SoSearchAction::Interest const interest)"""
        return _coin.SoSearchAction_setInterest(self, interest)

    def getInterest(self):
        r"""getInterest(SoSearchAction self) -> SoSearchAction::Interest"""
        return _coin.SoSearchAction_getInterest(self)

    def setSearchingAll(self, searchall):
        r"""setSearchingAll(SoSearchAction self, SbBool const searchall)"""
        return _coin.SoSearchAction_setSearchingAll(self, searchall)

    def isSearchingAll(self):
        r"""isSearchingAll(SoSearchAction self) -> SbBool"""
        return _coin.SoSearchAction_isSearchingAll(self)

    def getPath(self):
        r"""getPath(SoSearchAction self) -> SoPath"""
        return _coin.SoSearchAction_getPath(self)

    def getPaths(self):
        r"""getPaths(SoSearchAction self) -> SoPathList"""
        return _coin.SoSearchAction_getPaths(self)

    def reset(self):
        r"""reset(SoSearchAction self)"""
        return _coin.SoSearchAction_reset(self)

    def setFound(self):
        r"""setFound(SoSearchAction self)"""
        return _coin.SoSearchAction_setFound(self)

    def isFound(self):
        r"""isFound(SoSearchAction self) -> SbBool"""
        return _coin.SoSearchAction_isFound(self)

    def addPath(self, path):
        r"""addPath(SoSearchAction self, SoPath path)"""
        return _coin.SoSearchAction_addPath(self, path)
    duringSearchAll = property(_coin.SoSearchAction_duringSearchAll_get, _coin.SoSearchAction_duringSearchAll_set, doc=r"""duringSearchAll : SbBool""")

# Register SoSearchAction in _coin:
_coin.SoSearchAction_swigregister(SoSearchAction)
cvar = _coin.cvar

class SoSimplifyAction(SoAction):
    r"""Proxy of C++ SoSimplifyAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoSimplifyAction self) -> SoType"""
        return _coin.SoSimplifyAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSimplifyAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoSimplifyAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoSimplifyAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSimplifyAction_initClass()

    def __init__(self):
        r"""__init__(SoSimplifyAction self) -> SoSimplifyAction"""
        _coin.SoSimplifyAction_swiginit(self, _coin.new_SoSimplifyAction())
    __swig_destroy__ = _coin.delete_SoSimplifyAction

    def apply(self, *args):
        r"""
        apply(SoSimplifyAction self, SoNode root)
        apply(SoSimplifyAction self, SoPath path)
        apply(SoSimplifyAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoSimplifyAction_apply(self, *args)

# Register SoSimplifyAction in _coin:
_coin.SoSimplifyAction_swigregister(SoSimplifyAction)
class SoReorganizeAction(SoSimplifyAction):
    r"""Proxy of C++ SoReorganizeAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoReorganizeAction self) -> SoType"""
        return _coin.SoReorganizeAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoReorganizeAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoReorganizeAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoReorganizeAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoReorganizeAction_initClass()

    def __init__(self, simplifier=None):
        r"""__init__(SoReorganizeAction self, SoSimplifier * simplifier=None) -> SoReorganizeAction"""
        _coin.SoReorganizeAction_swiginit(self, _coin.new_SoReorganizeAction(simplifier))
    __swig_destroy__ = _coin.delete_SoReorganizeAction

    def getSimplifiedSceneGraph(self):
        r"""getSimplifiedSceneGraph(SoReorganizeAction self) -> SoSeparator"""
        return _coin.SoReorganizeAction_getSimplifiedSceneGraph(self)

    def generateNormals(self, onoff):
        r"""generateNormals(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateNormals(self, onoff)

    def areNormalGenerated(self):
        r"""areNormalGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areNormalGenerated(self)

    def generateTriangleStrips(self, onoff):
        r"""generateTriangleStrips(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateTriangleStrips(self, onoff)

    def areTriangleStripGenerated(self):
        r"""areTriangleStripGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areTriangleStripGenerated(self)

    def generateTexCoords(self, onoff):
        r"""generateTexCoords(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateTexCoords(self, onoff)

    def areTexCoordsGenerated(self):
        r"""areTexCoordsGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areTexCoordsGenerated(self)

    def generateVPNodes(self, onoff):
        r"""generateVPNodes(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_generateVPNodes(self, onoff)

    def areVPNodesGenerated(self):
        r"""areVPNodesGenerated(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areVPNodesGenerated(self)

    def matchIndexArrays(self, onoff):
        r"""matchIndexArrays(SoReorganizeAction self, SbBool onoff)"""
        return _coin.SoReorganizeAction_matchIndexArrays(self, onoff)

    def areIndexArraysMatched(self):
        r"""areIndexArraysMatched(SoReorganizeAction self) -> SbBool"""
        return _coin.SoReorganizeAction_areIndexArraysMatched(self)

    def getSimplifier(self):
        r"""getSimplifier(SoReorganizeAction self) -> SoSimplifier *"""
        return _coin.SoReorganizeAction_getSimplifier(self)

    def apply(self, *args):
        r"""
        apply(SoReorganizeAction self, SoNode root)
        apply(SoReorganizeAction self, SoPath path)
        apply(SoReorganizeAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoReorganizeAction_apply(self, *args)

    @staticmethod
    def startReport(msg):
        r"""startReport(char const * msg)"""
        return _coin.SoReorganizeAction_startReport(msg)

    @staticmethod
    def finishReport():
        r"""finishReport()"""
        return _coin.SoReorganizeAction_finishReport()

# Register SoReorganizeAction in _coin:
_coin.SoReorganizeAction_swigregister(SoReorganizeAction)
class SoWriteAction(SoAction):
    r"""Proxy of C++ SoWriteAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoWriteAction self) -> SoType"""
        return _coin.SoWriteAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWriteAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoWriteAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoWriteAction_enableElement(type, stackindex)

    def __init__(self, *args):
        r"""
        __init__(SoWriteAction self) -> SoWriteAction
        __init__(SoWriteAction self, SoOutput out) -> SoWriteAction
        """
        _coin.SoWriteAction_swiginit(self, _coin.new_SoWriteAction(*args))
    __swig_destroy__ = _coin.delete_SoWriteAction

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoWriteAction_initClass()

    def getOutput(self):
        r"""getOutput(SoWriteAction self) -> SoOutput"""
        return _coin.SoWriteAction_getOutput(self)

    def continueToApply(self, *args):
        r"""
        continueToApply(SoWriteAction self, SoNode node)
        continueToApply(SoWriteAction self, SoPath path)
        """
        return _coin.SoWriteAction_continueToApply(self, *args)

# Register SoWriteAction in _coin:
_coin.SoWriteAction_swigregister(SoWriteAction)
class SoAudioRenderAction(SoAction):
    r"""Proxy of C++ SoAudioRenderAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoAudioRenderAction self) -> SoType"""
        return _coin.SoAudioRenderAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAudioRenderAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoAudioRenderAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoAudioRenderAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAudioRenderAction_initClass()

    def __init__(self):
        r"""__init__(SoAudioRenderAction self) -> SoAudioRenderAction"""
        _coin.SoAudioRenderAction_swiginit(self, _coin.new_SoAudioRenderAction())
    __swig_destroy__ = _coin.delete_SoAudioRenderAction

    @staticmethod
    def callDoAction(action, node):
        r"""callDoAction(SoAction action, SoNode node)"""
        return _coin.SoAudioRenderAction_callDoAction(action, node)

    @staticmethod
    def callAudioRender(action, node):
        r"""callAudioRender(SoAction action, SoNode node)"""
        return _coin.SoAudioRenderAction_callAudioRender(action, node)

# Register SoAudioRenderAction in _coin:
_coin.SoAudioRenderAction_swigregister(SoAudioRenderAction)
class SoIntersectingPrimitive(object):
    r"""Proxy of C++ SoIntersectingPrimitive class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    path = property(_coin.SoIntersectingPrimitive_path_get, _coin.SoIntersectingPrimitive_path_set, doc=r"""path : p.SoPath""")
    SEGMENT = _coin.SoIntersectingPrimitive_SEGMENT
    
    LINE_SEGMENT = _coin.SoIntersectingPrimitive_LINE_SEGMENT
    
    TRIANGLE = _coin.SoIntersectingPrimitive_TRIANGLE
    
    type = property(_coin.SoIntersectingPrimitive_type_get, _coin.SoIntersectingPrimitive_type_set, doc=r"""type : enum SoIntersectingPrimitive::PrimitiveType""")
    vertex = property(_coin.SoIntersectingPrimitive_vertex_get, _coin.SoIntersectingPrimitive_vertex_set, doc=r"""vertex : a(3).SbVec3f""")
    xf_vertex = property(_coin.SoIntersectingPrimitive_xf_vertex_get, _coin.SoIntersectingPrimitive_xf_vertex_set, doc=r"""xf_vertex : a(3).SbVec3f""")

    def __init__(self):
        r"""__init__(SoIntersectingPrimitive self) -> SoIntersectingPrimitive"""
        _coin.SoIntersectingPrimitive_swiginit(self, _coin.new_SoIntersectingPrimitive())
    __swig_destroy__ = _coin.delete_SoIntersectingPrimitive

# Register SoIntersectingPrimitive in _coin:
_coin.SoIntersectingPrimitive_swigregister(SoIntersectingPrimitive)
class SoIntersectionDetectionAction(SoAction):
    r"""Proxy of C++ SoIntersectionDetectionAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoIntersectionDetectionAction self) -> SoType"""
        return _coin.SoIntersectionDetectionAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIntersectionDetectionAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoIntersectionDetectionAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoIntersectionDetectionAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIntersectionDetectionAction_initClass()

    def __init__(self):
        r"""__init__(SoIntersectionDetectionAction self) -> SoIntersectionDetectionAction"""
        _coin.SoIntersectionDetectionAction_swiginit(self, _coin.new_SoIntersectionDetectionAction())
    __swig_destroy__ = _coin.delete_SoIntersectionDetectionAction
    NEXT_PRIMITIVE = _coin.SoIntersectionDetectionAction_NEXT_PRIMITIVE
    
    NEXT_SHAPE = _coin.SoIntersectionDetectionAction_NEXT_SHAPE
    
    ABORT = _coin.SoIntersectionDetectionAction_ABORT
    

    def setIntersectionDetectionEpsilon(self, epsilon):
        r"""setIntersectionDetectionEpsilon(SoIntersectionDetectionAction self, float epsilon)"""
        return _coin.SoIntersectionDetectionAction_setIntersectionDetectionEpsilon(self, epsilon)

    def getIntersectionDetectionEpsilon(self):
        r"""getIntersectionDetectionEpsilon(SoIntersectionDetectionAction self) -> float"""
        return _coin.SoIntersectionDetectionAction_getIntersectionDetectionEpsilon(self)

    @staticmethod
    def setIntersectionEpsilon(epsilon):
        r"""setIntersectionEpsilon(float epsilon)"""
        return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon)

    @staticmethod
    def getIntersectionEpsilon():
        r"""getIntersectionEpsilon() -> float"""
        return _coin.SoIntersectionDetectionAction_getIntersectionEpsilon()

    def setTypeEnabled(self, type, enable):
        r"""setTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setTypeEnabled(self, type, enable)

    def isTypeEnabled(self, type, checkgroups=0):
        r"""isTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool checkgroups=0) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isTypeEnabled(self, type, checkgroups)

    def setManipsEnabled(self, enable):
        r"""setManipsEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setManipsEnabled(self, enable)

    def isManipsEnabled(self):
        r"""isManipsEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isManipsEnabled(self)

    def setDraggersEnabled(self, enable):
        r"""setDraggersEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setDraggersEnabled(self, enable)

    def isDraggersEnabled(self):
        r"""isDraggersEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isDraggersEnabled(self)

    def setShapeInternalsEnabled(self, enable):
        r"""setShapeInternalsEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
        return _coin.SoIntersectionDetectionAction_setShapeInternalsEnabled(self, enable)

    def isShapeInternalsEnabled(self):
        r"""isShapeInternalsEnabled(SoIntersectionDetectionAction self) -> SbBool"""
        return _coin.SoIntersectionDetectionAction_isShapeInternalsEnabled(self)

    def apply(self, *args):
        r"""
        apply(SoIntersectionDetectionAction self, SoNode node)
        apply(SoIntersectionDetectionAction self, SoPath path)
        apply(SoIntersectionDetectionAction self, SoPathList paths, SbBool obeysRules=0)
        """
        return _coin.SoIntersectionDetectionAction_apply(self, *args)

    def addVisitationCallback(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        setFilterCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionFilterCB * cb, void * closure=None)
        setFilterCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        """
        return _coin.SoIntersectionDetectionAction_setFilterCallback(self, *args)

    def addIntersectionCallback(self, *args):
        r"""
        addIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)
        addIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        """
        return _coin.SoIntersectionDetectionAction_addIntersectionCallback(self, *args)

    def removeIntersectionCallback(self, *args):
        r"""
        removeIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)
        removeIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
        """
        return _coin.SoIntersectionDetectionAction_removeIntersectionCallback(self, *args)

# Register SoIntersectionDetectionAction in _coin:
_coin.SoIntersectionDetectionAction_swigregister(SoIntersectionDetectionAction)
class SoToVRMLAction(SoAction):
    r"""Proxy of C++ SoToVRMLAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoToVRMLAction self) -> SoType"""
        return _coin.SoToVRMLAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoToVRMLAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoToVRMLAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoToVRMLAction_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoToVRMLAction_initClass()

    def __init__(self):
        r"""__init__(SoToVRMLAction self) -> SoToVRMLAction"""
        _coin.SoToVRMLAction_swiginit(self, _coin.new_SoToVRMLAction())
    __swig_destroy__ = _coin.delete_SoToVRMLAction

    def apply(self, *args):
        r"""
        apply(SoToVRMLAction self, SoNode node)
        apply(SoToVRMLAction self, SoPath path)
        apply(SoToVRMLAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoToVRMLAction_apply(self, *args)

    def getVRMLSceneGraph(self):
        r"""getVRMLSceneGraph(SoToVRMLAction self) -> SoNode"""
        return _coin.SoToVRMLAction_getVRMLSceneGraph(self)

    def expandSoFile(self, flag):
        r"""expandSoFile(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_expandSoFile(self, flag)

    def areSoFileExpanded(self):
        r"""areSoFileExpanded(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areSoFileExpanded(self)

    def setUrlName(self, name):
        r"""setUrlName(SoToVRMLAction self, SbString name)"""
        return _coin.SoToVRMLAction_setUrlName(self, name)

    def getUrlName(self):
        r"""getUrlName(SoToVRMLAction self) -> SbString"""
        return _coin.SoToVRMLAction_getUrlName(self)

    def writeTexCoords(self, flag):
        r"""writeTexCoords(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_writeTexCoords(self, flag)

    def areTexCoordWritten(self):
        r"""areTexCoordWritten(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areTexCoordWritten(self)

    def expandTexture2Node(self, flag):
        r"""expandTexture2Node(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_expandTexture2Node(self, flag)

    def areTexture2NodeExpanded(self):
        r"""areTexture2NodeExpanded(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areTexture2NodeExpanded(self)

    def keepUnknownNodes(self, flag):
        r"""keepUnknownNodes(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_keepUnknownNodes(self, flag)

    def areUnknownNodeKept(self):
        r"""areUnknownNodeKept(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_areUnknownNodeKept(self)

    def convertInlineNodes(self, flag):
        r"""convertInlineNodes(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_convertInlineNodes(self, flag)

    def doConvertInlineNodes(self):
        r"""doConvertInlineNodes(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_doConvertInlineNodes(self)

    def conditionalConversion(self, flag):
        r"""conditionalConversion(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_conditionalConversion(self, flag)

    def doConditionalConversion(self):
        r"""doConditionalConversion(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_doConditionalConversion(self)

    def setVerbosity(self, flag):
        r"""setVerbosity(SoToVRMLAction self, SbBool flag)"""
        return _coin.SoToVRMLAction_setVerbosity(self, flag)

    def isVerbose(self):
        r"""isVerbose(SoToVRMLAction self) -> SbBool"""
        return _coin.SoToVRMLAction_isVerbose(self)

# Register SoToVRMLAction in _coin:
_coin.SoToVRMLAction_swigregister(SoToVRMLAction)
class SoToVRML2Action(SoToVRMLAction):
    r"""Proxy of C++ SoToVRML2Action class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoToVRML2Action self) -> SoType"""
        return _coin.SoToVRML2Action_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoToVRML2Action_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoToVRML2Action_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoToVRML2Action_enableElement(type, stackindex)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoToVRML2Action_initClass()

    def __init__(self):
        r"""__init__(SoToVRML2Action self) -> SoToVRML2Action"""
        _coin.SoToVRML2Action_swiginit(self, _coin.new_SoToVRML2Action())
    __swig_destroy__ = _coin.delete_SoToVRML2Action

    def apply(self, *args):
        r"""
        apply(SoToVRML2Action self, SoNode node)
        apply(SoToVRML2Action self, SoPath path)
        apply(SoToVRML2Action self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoToVRML2Action_apply(self, *args)

    def getVRML2SceneGraph(self):
        r"""getVRML2SceneGraph(SoToVRML2Action self) -> SoVRMLGroup"""
        return _coin.SoToVRML2Action_getVRML2SceneGraph(self)

    def reuseAppearanceNodes(self, appearance):
        r"""reuseAppearanceNodes(SoToVRML2Action self, SbBool appearance)"""
        return _coin.SoToVRML2Action_reuseAppearanceNodes(self, appearance)

    def doReuseAppearanceNodes(self):
        r"""doReuseAppearanceNodes(SoToVRML2Action self) -> SbBool"""
        return _coin.SoToVRML2Action_doReuseAppearanceNodes(self)

    def reusePropertyNodes(self, property):
        r"""reusePropertyNodes(SoToVRML2Action self, SbBool property)"""
        return _coin.SoToVRML2Action_reusePropertyNodes(self, property)

    def doReusePropertyNodes(self):
        r"""doReusePropertyNodes(SoToVRML2Action self) -> SbBool"""
        return _coin.SoToVRML2Action_doReusePropertyNodes(self)

    def reuseGeometryNodes(self, geometry):
        r"""reuseGeometryNodes(SoToVRML2Action self, SbBool geometry)"""
        return _coin.SoToVRML2Action_reuseGeometryNodes(self, geometry)

    def doReuseGeometryNodes(self):
        r"""doReuseGeometryNodes(SoToVRML2Action self) -> SbBool"""
        return _coin.SoToVRML2Action_doReuseGeometryNodes(self)

# Register SoToVRML2Action in _coin:
_coin.SoToVRML2Action_swigregister(SoToVRML2Action)
class SoHardCopy(object):
    r"""Proxy of C++ SoHardCopy class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def init():
        r"""init()"""
        return _coin.SoHardCopy_init()

    @staticmethod
    def getProductName():
        r"""getProductName() -> char const *"""
        return _coin.SoHardCopy_getProductName()

    @staticmethod
    def getVersion():
        r"""getVersion() -> char const *"""
        return _coin.SoHardCopy_getVersion()

    def __init__(self):
        r"""__init__(SoHardCopy self) -> SoHardCopy"""
        _coin.SoHardCopy_swiginit(self, _coin.new_SoHardCopy())
    __swig_destroy__ = _coin.delete_SoHardCopy

# Register SoHardCopy in _coin:
_coin.SoHardCopy_swigregister(SoHardCopy)
class SoVectorOutput(object):
    r"""Proxy of C++ SoVectorOutput class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoVectorOutput self) -> SoVectorOutput"""
        _coin.SoVectorOutput_swiginit(self, _coin.new_SoVectorOutput())
    __swig_destroy__ = _coin.delete_SoVectorOutput

    def openFile(self, filename):
        r"""openFile(SoVectorOutput self, char const * filename) -> SbBool"""
        return _coin.SoVectorOutput_openFile(self, filename)

    def closeFile(self):
        r"""closeFile(SoVectorOutput self)"""
        return _coin.SoVectorOutput_closeFile(self)

    def getFilePointer(self):
        r"""getFilePointer(SoVectorOutput self) -> FILE *"""
        return _coin.SoVectorOutput_getFilePointer(self)

# Register SoVectorOutput in _coin:
_coin.SoVectorOutput_swigregister(SoVectorOutput)
class SoPSVectorOutput(SoVectorOutput):
    r"""Proxy of C++ SoPSVectorOutput class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoPSVectorOutput self) -> SoPSVectorOutput"""
        _coin.SoPSVectorOutput_swiginit(self, _coin.new_SoPSVectorOutput())
    __swig_destroy__ = _coin.delete_SoPSVectorOutput

    def setColored(self, flag=1):
        r"""setColored(SoPSVectorOutput self, SbBool flag=1)"""
        return _coin.SoPSVectorOutput_setColored(self, flag)

    def getColored(self):
        r"""getColored(SoPSVectorOutput self) -> SbBool"""
        return _coin.SoPSVectorOutput_getColored(self)

# Register SoPSVectorOutput in _coin:
_coin.SoPSVectorOutput_swigregister(SoPSVectorOutput)
class SoVectorizeAction(SoCallbackAction):
    r"""Proxy of C++ SoVectorizeAction class."""

    thisown = property(lambda x: 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):
        r"""getTypeId(SoVectorizeAction self) -> SoType"""
        return _coin.SoVectorizeAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVectorizeAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoVectorizeAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoVectorizeAction_enableElement(type, stackindex)
    __swig_destroy__ = _coin.delete_SoVectorizeAction

    def getOutput(self):
        r"""getOutput(SoVectorizeAction self) -> SoVectorOutput"""
        return _coin.SoVectorizeAction_getOutput(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVectorizeAction_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):
        r"""
        apply(SoVectorizeAction self, SoNode node)
        apply(SoVectorizeAction self, SoPath path)
        apply(SoVectorizeAction self, SoPathList pathlist, SbBool obeysrules=0)
        """
        return _coin.SoVectorizeAction_apply(self, *args)

    def beginStandardPage(self, pagesize, border=10.0):
        r"""beginStandardPage(SoVectorizeAction self, SoVectorizeAction::PageSize const & pagesize, float const border=10.0)"""
        return _coin.SoVectorizeAction_beginStandardPage(self, pagesize, border)

    def beginPage(self, *args):
        r"""beginPage(SoVectorizeAction self, SbVec2f startpagepos, SbVec2f pagesize, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_beginPage(self, *args)

    def endPage(self):
        r"""endPage(SoVectorizeAction self)"""
        return _coin.SoVectorizeAction_endPage(self)

    def calibrate(self, vp):
        r"""calibrate(SoVectorizeAction self, SbViewportRegion vp)"""
        return _coin.SoVectorizeAction_calibrate(self, vp)

    def beginViewport(self, *args):
        r"""beginViewport(SoVectorizeAction self, SbVec2f startpos=SbVec2f(-1.0f, 1.0f), SbVec2f size=SbVec2f(-1.0f, -1.0f), SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_beginViewport(self, *args)

    def endViewport(self):
        r"""endViewport(SoVectorizeAction self)"""
        return _coin.SoVectorizeAction_endViewport(self)

    def setOrientation(self, o):
        r"""setOrientation(SoVectorizeAction self, SoVectorizeAction::Orientation o)"""
        return _coin.SoVectorizeAction_setOrientation(self, o)

    def getOrientation(self):
        r"""getOrientation(SoVectorizeAction self) -> SoVectorizeAction::Orientation"""
        return _coin.SoVectorizeAction_getOrientation(self)

    def setBackgroundColor(self, *args):
        r"""setBackgroundColor(SoVectorizeAction self, SbBool bg, SbColor col=SbColor(0.0f, 0.0f, 0.0f))"""
        return _coin.SoVectorizeAction_setBackgroundColor(self, *args)

    def getBackgroundColor(self, col):
        r"""getBackgroundColor(SoVectorizeAction self, SbColor col) -> SbBool"""
        return _coin.SoVectorizeAction_getBackgroundColor(self, col)

    def setNominalWidth(self, *args):
        r"""setNominalWidth(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_setNominalWidth(self, *args)

    def getNominalWidth(self, *args):
        r"""getNominalWidth(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> float"""
        return _coin.SoVectorizeAction_getNominalWidth(self, *args)

    def setPixelImageSize(self, *args):
        r"""setPixelImageSize(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_setPixelImageSize(self, *args)

    def getPixelImageSize(self, *args):
        r"""getPixelImageSize(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> float"""
        return _coin.SoVectorizeAction_getPixelImageSize(self, *args)
    CIRCLE = _coin.SoVectorizeAction_CIRCLE
    
    SQUARE = _coin.SoVectorizeAction_SQUARE
    

    def setPointStyle(self, style):
        r"""setPointStyle(SoVectorizeAction self, SoVectorizeAction::PointStyle const & style)"""
        return _coin.SoVectorizeAction_setPointStyle(self, style)

    def getPointStyle(self):
        r"""getPointStyle(SoVectorizeAction self) -> SoVectorizeAction::PointStyle"""
        return _coin.SoVectorizeAction_getPointStyle(self)

    def getPageStartpos(self):
        r"""getPageStartpos(SoVectorizeAction self) -> SbVec2f"""
        return _coin.SoVectorizeAction_getPageStartpos(self)

    def getPageSize(self):
        r"""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):
        r"""
        setDrawingDimensions(SoVectorizeAction self, SbVec2f d, SoVectorizeAction::DimensionUnit u=MM)
        setDrawingDimensions(SoVectorizeAction self, float w, float h, SoVectorizeAction::DimensionUnit u=MM)
        """
        return _coin.SoVectorizeAction_setDrawingDimensions(self, *args)

    def getDrawingDimensions(self, *args):
        r"""getDrawingDimensions(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> SbVec2f"""
        return _coin.SoVectorizeAction_getDrawingDimensions(self, *args)

    def setStartPosition(self, *args):
        r"""
        setStartPosition(SoVectorizeAction self, SbVec2f p, SoVectorizeAction::DimensionUnit u=MM)
        setStartPosition(SoVectorizeAction self, float x, float y, SoVectorizeAction::DimensionUnit u=MM)
        """
        return _coin.SoVectorizeAction_setStartPosition(self, *args)

    def getStartPosition(self, *args):
        r"""getStartPosition(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u=MM) -> SbVec2f"""
        return _coin.SoVectorizeAction_getStartPosition(self, *args)

    def setColorTranslationMethod(self, method):
        r"""setColorTranslationMethod(SoVectorizeAction self, SoVectorizeAction::ColorTranslationMethod method)"""
        return _coin.SoVectorizeAction_setColorTranslationMethod(self, method)

    def getColorTranslationMethod(self):
        r"""getColorTranslationMethod(SoVectorizeAction self) -> SoVectorizeAction::ColorTranslationMethod"""
        return _coin.SoVectorizeAction_getColorTranslationMethod(self)

    def setLineEndStyle(self, style):
        r"""setLineEndStyle(SoVectorizeAction self, SoVectorizeAction::EndLineStyle style)"""
        return _coin.SoVectorizeAction_setLineEndStyle(self, style)

    def getLineEndStyle(self):
        r"""getLineEndStyle(SoVectorizeAction self) -> SoVectorizeAction::EndLineStyle"""
        return _coin.SoVectorizeAction_getLineEndStyle(self)

    def setLineJoinsStyle(self, style):
        r"""setLineJoinsStyle(SoVectorizeAction self, SoVectorizeAction::JoinLineStyle style)"""
        return _coin.SoVectorizeAction_setLineJoinsStyle(self, style)

    def getLineJoinsStyle(self):
        r"""getLineJoinsStyle(SoVectorizeAction self) -> SoVectorizeAction::JoinLineStyle"""
        return _coin.SoVectorizeAction_getLineJoinsStyle(self)

    def setHLHSRMode(self, mode):
        r"""setHLHSRMode(SoVectorizeAction self, SoVectorizeAction::HLHSRMode mode)"""
        return _coin.SoVectorizeAction_setHLHSRMode(self, mode)

    def getHLHSRMode(self):
        r"""getHLHSRMode(SoVectorizeAction self) -> SoVectorizeAction::HLHSRMode"""
        return _coin.SoVectorizeAction_getHLHSRMode(self)

    def setBorder(self, *args):
        r"""
        setBorder(SoVectorizeAction self, float width)
        setBorder(SoVectorizeAction self, float width, SbColor color)
        """
        return _coin.SoVectorizeAction_setBorder(self, *args)

    def setMiterLimit(self, limit):
        r"""setMiterLimit(SoVectorizeAction self, float limit)"""
        return _coin.SoVectorizeAction_setMiterLimit(self, limit)

    def getMiterLimit(self):
        r"""getMiterLimit(SoVectorizeAction self) -> float"""
        return _coin.SoVectorizeAction_getMiterLimit(self)

    def setPenDescription(self, *args):
        r"""setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None, float const * widths=None, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_setPenDescription(self, *args)

    def getPenDescription(self, *args):
        r"""getPenDescription(SoVectorizeAction self, SbColor colors, float * widths, SoVectorizeAction::DimensionUnit u=MM)"""
        return _coin.SoVectorizeAction_getPenDescription(self, *args)

    def getPenNum(self):
        r"""getPenNum(SoVectorizeAction self) -> int"""
        return _coin.SoVectorizeAction_getPenNum(self)

    def setColorPriority(self, priority):
        r"""setColorPriority(SoVectorizeAction self, SbBool priority)"""
        return _coin.SoVectorizeAction_setColorPriority(self, priority)

    def getColorPriority(self):
        r"""getColorPriority(SoVectorizeAction self) -> SbBool"""
        return _coin.SoVectorizeAction_getColorPriority(self)

    def enableLighting(self, flag):
        r"""enableLighting(SoVectorizeAction self, SbBool flag)"""
        return _coin.SoVectorizeAction_enableLighting(self, flag)

    def isLightingEnabled(self):
        r"""isLightingEnabled(SoVectorizeAction self) -> SbBool"""
        return _coin.SoVectorizeAction_isLightingEnabled(self)

# Register SoVectorizeAction in _coin:
_coin.SoVectorizeAction_swigregister(SoVectorizeAction)
class SoShape(SoNode):
    r"""Proxy of C++ SoShape class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShape_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShape self) -> SoType"""
        return _coin.SoShape_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShape_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):
        r"""affectsState(SoShape self) -> SbBool"""
        return _coin.SoShape_affectsState(self)

    def notify(self, nl):
        r"""notify(SoShape self, SoNotList nl)"""
        return _coin.SoShape_notify(self, nl)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoShape_getBoundingBox(self, action)

    def GLRender(self, action):
        r"""GLRender(SoShape self, SoGLRenderAction action)"""
        return _coin.SoShape_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoShape self, SoRayPickAction action)"""
        return _coin.SoShape_rayPick(self, action)

    def callback(self, action):
        r"""callback(SoShape self, SoCallbackAction action)"""
        return _coin.SoShape_callback(self, action)

    def computeBBox(self, action, box, center):
        r"""computeBBox(SoShape self, SoAction action, SbBox3f box, SbVec3f center)"""
        return _coin.SoShape_computeBBox(self, action, box, center)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoShape self, SoGetPrimitiveCountAction action)"""
        return _coin.SoShape_getPrimitiveCount(self, action)

    @staticmethod
    def getScreenSize(state, boundingbox, rectsize):
        r"""getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
        return _coin.SoShape_getScreenSize(state, boundingbox, rectsize)

    @staticmethod
    def getDecimatedComplexity(state, complexity):
        r"""getDecimatedComplexity(SoState state, float complexity) -> float"""
        return _coin.SoShape_getDecimatedComplexity(state, complexity)

    def getBoundingBoxCache(self):
        r"""getBoundingBoxCache(SoShape self) -> SoBoundingBoxCache"""
        return _coin.SoShape_getBoundingBoxCache(self)

# Register SoShape in _coin:
_coin.SoShape_swigregister(SoShape)
class SoImage(SoShape):
    r"""Proxy of C++ SoImage class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoImage_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoImage self) -> SoType"""
        return _coin.SoImage_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoImage_initClass()

    def __init__(self):
        r"""__init__(SoImage self) -> SoImage"""
        _coin.SoImage_swiginit(self, _coin.new_SoImage())
    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 = property(_coin.SoImage_width_get, _coin.SoImage_width_set, doc=r"""width : SoSFInt32""")
    height = property(_coin.SoImage_height_get, _coin.SoImage_height_set, doc=r"""height : SoSFInt32""")
    vertAlignment = property(_coin.SoImage_vertAlignment_get, _coin.SoImage_vertAlignment_set, doc=r"""vertAlignment : SoSFEnum""")
    horAlignment = property(_coin.SoImage_horAlignment_get, _coin.SoImage_horAlignment_set, doc=r"""horAlignment : SoSFEnum""")
    image = property(_coin.SoImage_image_get, _coin.SoImage_image_set, doc=r"""image : SoSFImage""")
    filename = property(_coin.SoImage_filename_get, _coin.SoImage_filename_set, doc=r"""filename : SoSFString""")

    def GLRender(self, action):
        r"""GLRender(SoImage self, SoGLRenderAction action)"""
        return _coin.SoImage_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoImage self, SoRayPickAction action)"""
        return _coin.SoImage_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoImage self, SoGetPrimitiveCountAction action)"""
        return _coin.SoImage_getPrimitiveCount(self, action)

# Register SoImage in _coin:
_coin.SoImage_swigregister(SoImage)
class SoVectorizePSAction(SoVectorizeAction):
    r"""Proxy of C++ SoVectorizePSAction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoVectorizePSAction self) -> SoType"""
        return _coin.SoVectorizePSAction_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVectorizePSAction_getClassTypeId()

    @staticmethod
    def addMethod(type, method):
        r"""addMethod(SoType type, SoActionMethod method)"""
        return _coin.SoVectorizePSAction_addMethod(type, method)

    @staticmethod
    def enableElement(type, stackindex):
        r"""enableElement(SoType type, int const stackindex)"""
        return _coin.SoVectorizePSAction_enableElement(type, stackindex)

    def __init__(self):
        r"""__init__(SoVectorizePSAction self) -> SoVectorizePSAction"""
        _coin.SoVectorizePSAction_swiginit(self, _coin.new_SoVectorizePSAction())
    __swig_destroy__ = _coin.delete_SoVectorizePSAction

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVectorizePSAction_initClass()

    def setDefault2DFont(self, fontname):
        r"""setDefault2DFont(SoVectorizePSAction self, SbString fontname)"""
        return _coin.SoVectorizePSAction_setDefault2DFont(self, fontname)

    def getDefault2DFont(self):
        r"""getDefault2DFont(SoVectorizePSAction self) -> SbString"""
        return _coin.SoVectorizePSAction_getDefault2DFont(self)

    def setGouraudThreshold(self, eps):
        r"""setGouraudThreshold(SoVectorizePSAction self, double const eps)"""
        return _coin.SoVectorizePSAction_setGouraudThreshold(self, eps)

    def getOutput(self):
        r"""getOutput(SoVectorizePSAction self) -> SoPSVectorOutput"""
        return _coin.SoVectorizePSAction_getOutput(self)

    def getPSOutput(self):
        r"""getPSOutput(SoVectorizePSAction self) -> SoPSVectorOutput"""
        return _coin.SoVectorizePSAction_getPSOutput(self)

# Register SoVectorizePSAction in _coin:
_coin.SoVectorizePSAction_swigregister(SoVectorizePSAction)
class SoBundle(object):
    r"""Proxy of C++ SoBundle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register SoBundle in _coin:
_coin.SoBundle_swigregister(SoBundle)
class SoMaterialBundle(SoBundle):
    r"""Proxy of C++ SoMaterialBundle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, action):
        r"""__init__(SoMaterialBundle self, SoAction action) -> SoMaterialBundle"""
        _coin.SoMaterialBundle_swiginit(self, _coin.new_SoMaterialBundle(action))
    __swig_destroy__ = _coin.delete_SoMaterialBundle

    def setUpMultiple(self):
        r"""setUpMultiple(SoMaterialBundle self)"""
        return _coin.SoMaterialBundle_setUpMultiple(self)

    def sendFirst(self):
        r"""sendFirst(SoMaterialBundle self)"""
        return _coin.SoMaterialBundle_sendFirst(self)

    def forceSend(self, index):
        r"""forceSend(SoMaterialBundle self, int const index)"""
        return _coin.SoMaterialBundle_forceSend(self, index)

    def isColorOnly(self):
        r"""isColorOnly(SoMaterialBundle self) -> SbBool"""
        return _coin.SoMaterialBundle_isColorOnly(self)

    def send(self, index, betweenbeginend):
        r"""send(SoMaterialBundle self, int const index, SbBool const betweenbeginend)"""
        return _coin.SoMaterialBundle_send(self, index, betweenbeginend)

# Register SoMaterialBundle in _coin:
_coin.SoMaterialBundle_swigregister(SoMaterialBundle)
class SbBSPTree(object):
    r"""Proxy of C++ SbBSPTree class."""

    thisown = 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):
        r"""__init__(SbBSPTree self, int const maxnodepts=64, int const initsize=4) -> SbBSPTree"""
        _coin.SbBSPTree_swiginit(self, _coin.new_SbBSPTree(maxnodepts, initsize))
    __swig_destroy__ = _coin.delete_SbBSPTree

    def numPoints(self):
        r"""numPoints(SbBSPTree self) -> int"""
        return _coin.SbBSPTree_numPoints(self)

    def getPoint(self, *args):
        r"""
        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):
        r"""getUserData(SbBSPTree self, int const idx) -> void *"""
        return _coin.SbBSPTree_getUserData(self, idx)

    def setUserData(self, idx, data):
        r"""setUserData(SbBSPTree self, int const idx, void *const data)"""
        return _coin.SbBSPTree_setUserData(self, idx, data)

    def addPoint(self, pt, userdata=None):
        r"""addPoint(SbBSPTree self, SbVec3f pt, void *const userdata=None) -> int"""
        return _coin.SbBSPTree_addPoint(self, pt, userdata)

    def removePoint(self, *args):
        r"""
        removePoint(SbBSPTree self, SbVec3f pt) -> int
        removePoint(SbBSPTree self, int const idx)
        """
        return _coin.SbBSPTree_removePoint(self, *args)

    def findPoint(self, pos):
        r"""findPoint(SbBSPTree self, SbVec3f pos) -> int"""
        return _coin.SbBSPTree_findPoint(self, pos)

    def clear(self, initsize=4):
        r"""clear(SbBSPTree self, int const initsize=4)"""
        return _coin.SbBSPTree_clear(self, initsize)

    def getBBox(self):
        r"""getBBox(SbBSPTree self) -> SbBox3f"""
        return _coin.SbBSPTree_getBBox(self)

    def getPointsArrayPtr(self):
        r"""getPointsArrayPtr(SbBSPTree self) -> SbVec3f"""
        return _coin.SbBSPTree_getPointsArrayPtr(self)

    def findPoints(self, *args):
        r"""
        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):
        r"""
        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)

# Register SbBSPTree in _coin:
_coin.SbBSPTree_swigregister(SbBSPTree)
class SoNormalGenerator(object):
    r"""Proxy of C++ SoNormalGenerator class."""

    thisown = 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):
        r"""__init__(SoNormalGenerator self, SbBool const ccw, int const approxVertices=64) -> SoNormalGenerator"""
        _coin.SoNormalGenerator_swiginit(self, _coin.new_SoNormalGenerator(ccw, approxVertices))
    __swig_destroy__ = _coin.delete_SoNormalGenerator

    def reset(self, ccw):
        r"""reset(SoNormalGenerator self, SbBool const ccw)"""
        return _coin.SoNormalGenerator_reset(self, ccw)

    def beginPolygon(self):
        r"""beginPolygon(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_beginPolygon(self)

    def polygonVertex(self, v):
        r"""polygonVertex(SoNormalGenerator self, SbVec3f v)"""
        return _coin.SoNormalGenerator_polygonVertex(self, v)

    def endPolygon(self):
        r"""endPolygon(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_endPolygon(self)

    def triangle(self, v0, v1, v2):
        r"""triangle(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2)"""
        return _coin.SoNormalGenerator_triangle(self, v0, v1, v2)

    def quad(self, v0, v1, v2, v3):
        r"""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):
        r"""generate(SoNormalGenerator self, float const creaseAngle, int32_t const * striplens=None, int const numstrips=0)"""
        return _coin.SoNormalGenerator_generate(self, creaseAngle, striplens, numstrips)

    def generatePerStrip(self, striplens, numstrips):
        r"""generatePerStrip(SoNormalGenerator self, int32_t const * striplens, int const numstrips)"""
        return _coin.SoNormalGenerator_generatePerStrip(self, striplens, numstrips)

    def generatePerFace(self):
        r"""generatePerFace(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_generatePerFace(self)

    def generateOverall(self):
        r"""generateOverall(SoNormalGenerator self)"""
        return _coin.SoNormalGenerator_generateOverall(self)

    def getNumNormals(self):
        r"""getNumNormals(SoNormalGenerator self) -> int"""
        return _coin.SoNormalGenerator_getNumNormals(self)

    def setNumNormals(self, num):
        r"""setNumNormals(SoNormalGenerator self, int const num)"""
        return _coin.SoNormalGenerator_setNumNormals(self, num)

    def getNormals(self):
        r"""getNormals(SoNormalGenerator self) -> SbVec3f"""
        return _coin.SoNormalGenerator_getNormals(self)

    def getNormal(self, i):
        r"""getNormal(SoNormalGenerator self, int32_t const i) -> SbVec3f"""
        return _coin.SoNormalGenerator_getNormal(self, i)

    def setNormal(self, index, normal):
        r"""setNormal(SoNormalGenerator self, int32_t const index, SbVec3f normal)"""
        return _coin.SoNormalGenerator_setNormal(self, index, normal)

# Register SoNormalGenerator in _coin:
_coin.SoNormalGenerator_swigregister(SoNormalGenerator)
class SoNormalElement(SoReplacedElement):
    r"""Proxy of C++ SoNormalElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNormalElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoNormalElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoNormalElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNormalElement_initClass()

    def init(self, state):
        r"""init(SoNormalElement self, SoState state)"""
        return _coin.SoNormalElement_init(self, state)

    @staticmethod
    def set(state, node, numNormals, normals, normalsAreUnitLength=0):
        r"""set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals, SbBool const normalsAreUnitLength=0)"""
        return _coin.SoNormalElement_set(state, node, numNormals, normals, normalsAreUnitLength)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoNormalElement"""
        return _coin.SoNormalElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoNormalElement self) -> int32_t"""
        return _coin.SoNormalElement_getNum(self)

    def get(self, index):
        r"""get(SoNormalElement self, int const index) -> SbVec3f"""
        return _coin.SoNormalElement_get(self, index)

    def getArrayPtr(self):
        r"""getArrayPtr(SoNormalElement self) -> SbVec3f"""
        return _coin.SoNormalElement_getArrayPtr(self)

    def areNormalsUnitLength(self):
        r"""areNormalsUnitLength(SoNormalElement self) -> SbBool"""
        return _coin.SoNormalElement_areNormalsUnitLength(self)

# Register SoNormalElement in _coin:
_coin.SoNormalElement_swigregister(SoNormalElement)
class SoGLNormalElement(SoNormalElement):
    r"""Proxy of C++ SoGLNormalElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLNormalElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLNormalElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLNormalElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLNormalElement_initClass()

    def init(self, state):
        r"""init(SoGLNormalElement self, SoState state)"""
        return _coin.SoGLNormalElement_init(self, state)

    def send(self, index):
        r"""send(SoGLNormalElement self, int const index)"""
        return _coin.SoGLNormalElement_send(self, index)

# Register SoGLNormalElement in _coin:
_coin.SoGLNormalElement_swigregister(SoGLNormalElement)
class SoNormalBundle(SoBundle):
    r"""Proxy of C++ SoNormalBundle class."""

    thisown = property(lambda x: x.this.own(), 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 = property(_coin.SoNormalBundle_generator_get, _coin.SoNormalBundle_generator_set, doc=r"""generator : p.SoNormalGenerator""")

# Register SoNormalBundle in _coin:
_coin.SoNormalBundle_swigregister(SoNormalBundle)
class SoTextureCoordinateElement(SoReplacedElement):
    r"""Proxy of C++ SoTextureCoordinateElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureCoordinateElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateElement_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):
        r"""init(SoTextureCoordinateElement self, SoState state)"""
        return _coin.SoTextureCoordinateElement_init(self, state)

    @staticmethod
    def setDefault(state, node):
        r"""setDefault(SoState state, SoNode node)"""
        return _coin.SoTextureCoordinateElement_setDefault(state, node)

    @staticmethod
    def setFunction(state, node, func, userdata):
        r"""setFunction(SoState state, SoNode node, SoTextureCoordinateFunctionCB *const func, void *const userdata)"""
        return _coin.SoTextureCoordinateElement_setFunction(state, node, func, userdata)

    @staticmethod
    def set2(state, node, numCoords, coords):
        r"""set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"""
        return _coin.SoTextureCoordinateElement_set2(state, node, numCoords, coords)

    @staticmethod
    def set3(state, node, numCoords, coords):
        r"""set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoTextureCoordinateElement_set3(state, node, numCoords, coords)

    @staticmethod
    def set4(state, node, numCoords, coords):
        r"""set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
        return _coin.SoTextureCoordinateElement_set4(state, node, numCoords, coords)

    def getType(self, *args):
        r"""
        getType(SoTextureCoordinateElement self, SoState state) -> SoTextureCoordinateElement::CoordType
        getType(SoTextureCoordinateElement self) -> SoTextureCoordinateElement::CoordType
        """
        return _coin.SoTextureCoordinateElement_getType(self, *args)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoTextureCoordinateElement"""
        return _coin.SoTextureCoordinateElement_getInstance(state)

    def get(self, point, normal):
        r"""get(SoTextureCoordinateElement self, SbVec3f point, SbVec3f normal) -> SbVec4f"""
        return _coin.SoTextureCoordinateElement_get(self, point, normal)

    def getNum(self):
        r"""getNum(SoTextureCoordinateElement self) -> int32_t"""
        return _coin.SoTextureCoordinateElement_getNum(self)

    def is2D(self):
        r"""is2D(SoTextureCoordinateElement self) -> SbBool"""
        return _coin.SoTextureCoordinateElement_is2D(self)

    def getDimension(self):
        r"""getDimension(SoTextureCoordinateElement self) -> int32_t"""
        return _coin.SoTextureCoordinateElement_getDimension(self)

    def get2(self, index):
        r"""get2(SoTextureCoordinateElement self, int const index) -> SbVec2f"""
        return _coin.SoTextureCoordinateElement_get2(self, index)

    def get3(self, index):
        r"""get3(SoTextureCoordinateElement self, int const index) -> SbVec3f"""
        return _coin.SoTextureCoordinateElement_get3(self, index)

    def get4(self, index):
        r"""get4(SoTextureCoordinateElement self, int const index) -> SbVec4f"""
        return _coin.SoTextureCoordinateElement_get4(self, index)

    def getArrayPtr2(self):
        r"""getArrayPtr2(SoTextureCoordinateElement self) -> SbVec2f"""
        return _coin.SoTextureCoordinateElement_getArrayPtr2(self)

    def getArrayPtr3(self):
        r"""getArrayPtr3(SoTextureCoordinateElement self) -> SbVec3f"""
        return _coin.SoTextureCoordinateElement_getArrayPtr3(self)

    def getArrayPtr4(self):
        r"""getArrayPtr4(SoTextureCoordinateElement self) -> SbVec4f"""
        return _coin.SoTextureCoordinateElement_getArrayPtr4(self)

# Register SoTextureCoordinateElement in _coin:
_coin.SoTextureCoordinateElement_swigregister(SoTextureCoordinateElement)
class SoGLTextureCoordinateElement(SoTextureCoordinateElement):
    r"""Proxy of C++ SoGLTextureCoordinateElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLTextureCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLTextureCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLTextureCoordinateElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLTextureCoordinateElement_initClass()

    def init(self, state):
        r"""init(SoGLTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_init(self, state)

    def push(self, state):
        r"""push(SoGLTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLTextureCoordinateElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureCoordinateElement_pop(self, state, prevTopElement)

    @staticmethod
    def setTexGen(state, node, texgenFunc, texgenData=None, func=None, funcData=None):
        r"""setTexGen(SoState state, SoNode node, SoTexCoordTexgenCB *const texgenFunc, void *const texgenData=None, SoTextureCoordinateFunctionCB *const func=None, void *const funcData=None)"""
        return _coin.SoGLTextureCoordinateElement_setTexGen(state, node, texgenFunc, texgenData, func, funcData)

    def getType(self):
        r"""getType(SoGLTextureCoordinateElement self) -> SoTextureCoordinateElement::CoordType"""
        return _coin.SoGLTextureCoordinateElement_getType(self)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoGLTextureCoordinateElement"""
        return _coin.SoGLTextureCoordinateElement_getInstance(state)

    def send(self, *args):
        r"""
        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):
        r"""initMulti(SoGLTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLTextureCoordinateElement_initMulti(self, state)

# Register SoGLTextureCoordinateElement in _coin:
_coin.SoGLTextureCoordinateElement_swigregister(SoGLTextureCoordinateElement)
class SoTextureCoordinateBundle(SoBundle):
    r"""Proxy of C++ SoTextureCoordinateBundle class."""

    thisown = 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):
        r"""__init__(SoTextureCoordinateBundle self, SoAction action, SbBool const forRendering, SbBool const setUpDefault=1) -> SoTextureCoordinateBundle"""
        _coin.SoTextureCoordinateBundle_swiginit(self, _coin.new_SoTextureCoordinateBundle(action, forRendering, setUpDefault))
    __swig_destroy__ = _coin.delete_SoTextureCoordinateBundle

    def needCoordinates(self):
        r"""needCoordinates(SoTextureCoordinateBundle self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_needCoordinates(self)

    def isFunction(self):
        r"""isFunction(SoTextureCoordinateBundle self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_isFunction(self)

    def get(self, *args):
        r"""
        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):
        r"""
        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):
        r"""needIndices(SoTextureCoordinateBundle self) -> SbBool"""
        return _coin.SoTextureCoordinateBundle_needIndices(self)

# Register SoTextureCoordinateBundle in _coin:
_coin.SoTextureCoordinateBundle_swigregister(SoTextureCoordinateBundle)
class SoCache(object):
    r"""Proxy of C++ SoCache class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, state):
        r"""__init__(SoCache self, SoState state) -> SoCache"""
        _coin.SoCache_swiginit(self, _coin.new_SoCache(state))

    def ref(self):
        r"""ref(SoCache self)"""
        return _coin.SoCache_ref(self)

    def unref(self, state=None):
        r"""unref(SoCache self, SoState state=None)"""
        return _coin.SoCache_unref(self, state)

    def addElement(self, elem):
        r"""addElement(SoCache self, SoElement elem)"""
        return _coin.SoCache_addElement(self, elem)

    def addCacheDependency(self, state, cache):
        r"""addCacheDependency(SoCache self, SoState state, SoCache cache)"""
        return _coin.SoCache_addCacheDependency(self, state, cache)

    def isValid(self, state):
        r"""isValid(SoCache self, SoState state) -> SbBool"""
        return _coin.SoCache_isValid(self, state)

    def getInvalidElement(self, state):
        r"""getInvalidElement(SoCache self, SoState state) -> SoElement"""
        return _coin.SoCache_getInvalidElement(self, state)

    def invalidate(self):
        r"""invalidate(SoCache self)"""
        return _coin.SoCache_invalidate(self)

# Register SoCache in _coin:
_coin.SoCache_swigregister(SoCache)
class SoBoundingBoxCache(SoCache):
    r"""Proxy of C++ SoBoundingBoxCache class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, state):
        r"""__init__(SoBoundingBoxCache self, SoState state) -> SoBoundingBoxCache"""
        _coin.SoBoundingBoxCache_swiginit(self, _coin.new_SoBoundingBoxCache(state))
    __swig_destroy__ = _coin.delete_SoBoundingBoxCache

    def set(self, boundingbox, centerset, centerpoint):
        r"""set(SoBoundingBoxCache self, SbXfBox3f boundingbox, SbBool centerset, SbVec3f centerpoint)"""
        return _coin.SoBoundingBoxCache_set(self, boundingbox, centerset, centerpoint)

    def getBox(self):
        r"""getBox(SoBoundingBoxCache self) -> SbXfBox3f"""
        return _coin.SoBoundingBoxCache_getBox(self)

    def getProjectedBox(self):
        r"""getProjectedBox(SoBoundingBoxCache self) -> SbBox3f"""
        return _coin.SoBoundingBoxCache_getProjectedBox(self)

    def isCenterSet(self):
        r"""isCenterSet(SoBoundingBoxCache self) -> SbBool"""
        return _coin.SoBoundingBoxCache_isCenterSet(self)

    def getCenter(self):
        r"""getCenter(SoBoundingBoxCache self) -> SbVec3f"""
        return _coin.SoBoundingBoxCache_getCenter(self)

    @staticmethod
    def setHasLinesOrPoints(state):
        r"""setHasLinesOrPoints(SoState state)"""
        return _coin.SoBoundingBoxCache_setHasLinesOrPoints(state)

    def hasLinesOrPoints(self):
        r"""hasLinesOrPoints(SoBoundingBoxCache self) -> SbBool"""
        return _coin.SoBoundingBoxCache_hasLinesOrPoints(self)

# Register SoBoundingBoxCache in _coin:
_coin.SoBoundingBoxCache_swigregister(SoBoundingBoxCache)
class SoConvexDataCache(SoCache):
    r"""Proxy of C++ SoConvexDataCache class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, state):
        r"""__init__(SoConvexDataCache self, SoState state) -> SoConvexDataCache"""
        _coin.SoConvexDataCache_swiginit(self, _coin.new_SoConvexDataCache(state))
    __swig_destroy__ = _coin.delete_SoConvexDataCache
    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):
        r"""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):
        r"""getCoordIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getCoordIndices(self)

    def getNumCoordIndices(self):
        r"""getNumCoordIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumCoordIndices(self)

    def getMaterialIndices(self):
        r"""getMaterialIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getMaterialIndices(self)

    def getNumMaterialIndices(self):
        r"""getNumMaterialIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumMaterialIndices(self)

    def getNormalIndices(self):
        r"""getNormalIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getNormalIndices(self)

    def getNumNormalIndices(self):
        r"""getNumNormalIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumNormalIndices(self)

    def getTexIndices(self):
        r"""getTexIndices(SoConvexDataCache self) -> int32_t const *"""
        return _coin.SoConvexDataCache_getTexIndices(self)

    def getNumTexIndices(self):
        r"""getNumTexIndices(SoConvexDataCache self) -> int"""
        return _coin.SoConvexDataCache_getNumTexIndices(self)

# Register SoConvexDataCache in _coin:
_coin.SoConvexDataCache_swigregister(SoConvexDataCache)
class SoGLCacheList(object):
    r"""Proxy of C++ SoGLCacheList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register SoGLCacheList in _coin:
_coin.SoGLCacheList_swigregister(SoGLCacheList)
class SoGLLazyElement(SoLazyElement):
    r"""Proxy of C++ SoGLLazyElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLLazyElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLLazyElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLLazyElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLLazyElement_initClass()

    def init(self, state):
        r"""init(SoGLLazyElement self, SoState state)"""
        return _coin.SoGLLazyElement_init(self, state)

    def push(self, state):
        r"""push(SoGLLazyElement self, SoState state)"""
        return _coin.SoGLLazyElement_push(self, state)

    def pop(self, state, prevtopelement):
        r"""pop(SoGLLazyElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoGLLazyElement_pop(self, state, prevtopelement)

    @staticmethod
    def sendAllMaterial(state):
        r"""sendAllMaterial(SoState state)"""
        return _coin.SoGLLazyElement_sendAllMaterial(state)

    @staticmethod
    def sendNoMaterial(state):
        r"""sendNoMaterial(SoState state)"""
        return _coin.SoGLLazyElement_sendNoMaterial(state)

    @staticmethod
    def sendOnlyDiffuseColor(state):
        r"""sendOnlyDiffuseColor(SoState state)"""
        return _coin.SoGLLazyElement_sendOnlyDiffuseColor(state)

    @staticmethod
    def sendLightModel(state, model):
        r"""sendLightModel(SoState state, int32_t const model)"""
        return _coin.SoGLLazyElement_sendLightModel(state, model)

    @staticmethod
    def sendPackedDiffuse(state, diffuse):
        r"""sendPackedDiffuse(SoState state, uint32_t const diffuse)"""
        return _coin.SoGLLazyElement_sendPackedDiffuse(state, diffuse)

    @staticmethod
    def sendFlatshading(state, onoff):
        r"""sendFlatshading(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendFlatshading(state, onoff)

    @staticmethod
    def sendVertexOrdering(state, ordering):
        r"""sendVertexOrdering(SoState state, SoLazyElement::VertexOrdering const ordering)"""
        return _coin.SoGLLazyElement_sendVertexOrdering(state, ordering)

    @staticmethod
    def sendTwosideLighting(state, onoff):
        r"""sendTwosideLighting(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendTwosideLighting(state, onoff)

    @staticmethod
    def sendBackfaceCulling(state, onoff):
        r"""sendBackfaceCulling(SoState state, SbBool const onoff)"""
        return _coin.SoGLLazyElement_sendBackfaceCulling(state, onoff)

    def sendDiffuseByIndex(self, index):
        r"""sendDiffuseByIndex(SoGLLazyElement self, int const index)"""
        return _coin.SoGLLazyElement_sendDiffuseByIndex(self, index)

    @staticmethod
    def isColorIndex(state):
        r"""isColorIndex(SoState state) -> SbBool"""
        return _coin.SoGLLazyElement_isColorIndex(state)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoGLLazyElement"""
        return _coin.SoGLLazyElement_getInstance(state)

    def send(self, state, mask):
        r"""send(SoGLLazyElement self, SoState state, uint32_t mask)"""
        return _coin.SoGLLazyElement_send(self, state, mask)

    def sendVPPacked(self, state, pcolor):
        r"""sendVPPacked(SoGLLazyElement self, SoState state, unsigned char const * pcolor)"""
        return _coin.SoGLLazyElement_sendVPPacked(self, state, pcolor)

    def reset(self, state, bitmask):
        r"""reset(SoGLLazyElement self, SoState state, uint32_t bitmask)"""
        return _coin.SoGLLazyElement_reset(self, state, bitmask)

    def setDiffuseElt(self, arg2, numcolors, colors, packer):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""setTranspTypeElt(SoGLLazyElement self, int32_t type)"""
        return _coin.SoGLLazyElement_setTranspTypeElt(self, type)

    def setAmbientElt(self, color):
        r"""setAmbientElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setAmbientElt(self, color)

    def setEmissiveElt(self, color):
        r"""setEmissiveElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setEmissiveElt(self, color)

    def setSpecularElt(self, color):
        r"""setSpecularElt(SoGLLazyElement self, SbColor color)"""
        return _coin.SoGLLazyElement_setSpecularElt(self, color)

    def setShininessElt(self, value):
        r"""setShininessElt(SoGLLazyElement self, float value)"""
        return _coin.SoGLLazyElement_setShininessElt(self, value)

    def setColorMaterialElt(self, value):
        r"""setColorMaterialElt(SoGLLazyElement self, SbBool value)"""
        return _coin.SoGLLazyElement_setColorMaterialElt(self, value)

    def enableBlendingElt(self, sfactor, dfactor, alpha_sfactor, alpha_dfactor):
        r"""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):
        r"""disableBlendingElt(SoGLLazyElement self)"""
        return _coin.SoGLLazyElement_disableBlendingElt(self)

    def setLightModelElt(self, state, model):
        r"""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):
        r"""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):
        r"""setVertexOrderingElt(SoGLLazyElement self, SoLazyElement::VertexOrdering ordering)"""
        return _coin.SoGLLazyElement_setVertexOrderingElt(self, ordering)

    def setBackfaceCullingElt(self, onoff):
        r"""setBackfaceCullingElt(SoGLLazyElement self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setBackfaceCullingElt(self, onoff)

    def setTwosideLightingElt(self, onoff):
        r"""setTwosideLightingElt(SoGLLazyElement self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setTwosideLightingElt(self, onoff)

    def setShadeModelElt(self, flatshading):
        r"""setShadeModelElt(SoGLLazyElement self, SbBool flatshading)"""
        return _coin.SoGLLazyElement_setShadeModelElt(self, flatshading)

    def setGLImageIdElt(self, glimageid, alphatest):
        r"""setGLImageIdElt(SoGLLazyElement self, uint32_t glimageid, SbBool alphatest)"""
        return _coin.SoGLLazyElement_setGLImageIdElt(self, glimageid, alphatest)

    def setAlphaTestElt(self, onoff):
        r"""setAlphaTestElt(SoGLLazyElement self, SbBool onoff)"""
        return _coin.SoGLLazyElement_setAlphaTestElt(self, onoff)

    @staticmethod
    def beginCaching(state, prestate, poststate):
        r"""beginCaching(SoState state, SoGLLazyElement::GLState * prestate, SoGLLazyElement::GLState * poststate)"""
        return _coin.SoGLLazyElement_beginCaching(state, prestate, poststate)

    @staticmethod
    def endCaching(state):
        r"""endCaching(SoState state)"""
        return _coin.SoGLLazyElement_endCaching(state)

    @staticmethod
    def preCacheCall(state, prestate):
        r"""preCacheCall(SoState state, SoGLLazyElement::GLState * prestate) -> SbBool"""
        return _coin.SoGLLazyElement_preCacheCall(state, prestate)

    @staticmethod
    def postCacheCall(state, poststate):
        r"""postCacheCall(SoState state, SoGLLazyElement::GLState * poststate)"""
        return _coin.SoGLLazyElement_postCacheCall(state, poststate)

    @staticmethod
    def mergeCacheInfo(state, childprestate, childpoststate):
        r"""mergeCacheInfo(SoState state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate)"""
        return _coin.SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate)

    def updateColorVBO(self, vbo):
        r"""updateColorVBO(SoGLLazyElement self, SoVBO * vbo)"""
        return _coin.SoGLLazyElement_updateColorVBO(self, vbo)

# Register SoGLLazyElement in _coin:
_coin.SoGLLazyElement_swigregister(SoGLLazyElement)
class SoGLRenderCache(SoCache):
    r"""Proxy of C++ SoGLRenderCache class."""

    thisown = property(lambda x: x.this.own(), 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

    def isValid(self, state):
        r"""isValid(SoGLRenderCache self, SoState state) -> SbBool"""
        return _coin.SoGLRenderCache_isValid(self, state)

    def addNestedCache(self, child):
        r"""addNestedCache(SoGLRenderCache self, SoGLDisplayList child)"""
        return _coin.SoGLRenderCache_addNestedCache(self, child)

# Register SoGLRenderCache in _coin:
_coin.SoGLRenderCache_swigregister(SoGLRenderCache)
class SoNormalCache(SoCache):
    r"""Proxy of C++ SoNormalCache class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, state):
        r"""__init__(SoNormalCache self, SoState state) -> SoNormalCache"""
        _coin.SoNormalCache_swiginit(self, _coin.new_SoNormalCache(state))
    __swig_destroy__ = _coin.delete_SoNormalCache

    def set(self, *args):
        r"""
        set(SoNormalCache self, int const num, SbVec3f normals)
        set(SoNormalCache self, SoNormalGenerator generator)
        """
        return _coin.SoNormalCache_set(self, *args)

    def getNum(self):
        r"""getNum(SoNormalCache self) -> int"""
        return _coin.SoNormalCache_getNum(self)

    def getNormals(self):
        r"""getNormals(SoNormalCache self) -> SbVec3f"""
        return _coin.SoNormalCache_getNormals(self)

    def getNumIndices(self):
        r"""getNumIndices(SoNormalCache self) -> int"""
        return _coin.SoNormalCache_getNumIndices(self)

    def getIndices(self):
        r"""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):
        r"""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)"""
        return _coin.SoNormalCache_generatePerVertex(self, coords, numcoords, coordindices, numcoordindices, crease_angle, facenormals, numfacenormals, ccw, tristrip)

    def generatePerFace(self, coords, numcoords, coordindices, numcoorindices, ccw):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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)

# Register SoNormalCache in _coin:
_coin.SoNormalCache_swigregister(SoNormalCache)
class SoTextureCoordinateCache(SoCache):
    r"""Proxy of C++ SoTextureCoordinateCache class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, state):
        r"""__init__(SoTextureCoordinateCache self, SoState state) -> SoTextureCoordinateCache"""
        _coin.SoTextureCoordinateCache_swiginit(self, _coin.new_SoTextureCoordinateCache(state))
    __swig_destroy__ = _coin.delete_SoTextureCoordinateCache

    def generate(self, bbox, vertices, numvertices):
        r"""generate(SoTextureCoordinateCache self, SbBox3f bbox, SbVec3f vertices, int const numvertices)"""
        return _coin.SoTextureCoordinateCache_generate(self, bbox, vertices, numvertices)

    def get(self):
        r"""get(SoTextureCoordinateCache self) -> SbVec2f"""
        return _coin.SoTextureCoordinateCache_get(self)

    def getNum(self):
        r"""getNum(SoTextureCoordinateCache self) -> int"""
        return _coin.SoTextureCoordinateCache_getNum(self)

# Register SoTextureCoordinateCache in _coin:
_coin.SoTextureCoordinateCache_swigregister(SoTextureCoordinateCache)
class SoDetail(object):
    r"""Proxy of C++ SoDetail class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDetail_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoDetail_initClasses()

    def copy(self):
        r"""copy(SoDetail self) -> SoDetail"""
        return _coin.SoDetail_copy(self)

    def getTypeId(self):
        r"""getTypeId(SoDetail self) -> SoType"""
        return _coin.SoDetail_getTypeId(self)

    def isOfType(self, type):
        r"""isOfType(SoDetail self, SoType type) -> SbBool"""
        return _coin.SoDetail_isOfType(self, type)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDetail_getClassTypeId()

# Register SoDetail in _coin:
_coin.SoDetail_swigregister(SoDetail)
class SoConeDetail(SoDetail):
    r"""Proxy of C++ SoConeDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoConeDetail self) -> SoType"""
        return _coin.SoConeDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoConeDetail_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoConeDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoConeDetail self) -> SoConeDetail"""
        _coin.SoConeDetail_swiginit(self, _coin.new_SoConeDetail())
    __swig_destroy__ = _coin.delete_SoConeDetail

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoConeDetail_initClass()

    def copy(self):
        r"""copy(SoConeDetail self) -> SoDetail"""
        return _coin.SoConeDetail_copy(self)

    def setPart(self, part):
        r"""setPart(SoConeDetail self, int const part)"""
        return _coin.SoConeDetail_setPart(self, part)

    def getPart(self):
        r"""getPart(SoConeDetail self) -> int"""
        return _coin.SoConeDetail_getPart(self)

# Register SoConeDetail in _coin:
_coin.SoConeDetail_swigregister(SoConeDetail)
class SoCubeDetail(SoDetail):
    r"""Proxy of C++ SoCubeDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoCubeDetail self) -> SoType"""
        return _coin.SoCubeDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCubeDetail_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoCubeDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoCubeDetail self) -> SoCubeDetail"""
        _coin.SoCubeDetail_swiginit(self, _coin.new_SoCubeDetail())
    __swig_destroy__ = _coin.delete_SoCubeDetail

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCubeDetail_initClass()

    def copy(self):
        r"""copy(SoCubeDetail self) -> SoDetail"""
        return _coin.SoCubeDetail_copy(self)

    def setPart(self, part):
        r"""setPart(SoCubeDetail self, int const part)"""
        return _coin.SoCubeDetail_setPart(self, part)

    def getPart(self):
        r"""getPart(SoCubeDetail self) -> int"""
        return _coin.SoCubeDetail_getPart(self)

# Register SoCubeDetail in _coin:
_coin.SoCubeDetail_swigregister(SoCubeDetail)
class SoCylinderDetail(SoDetail):
    r"""Proxy of C++ SoCylinderDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoCylinderDetail self) -> SoType"""
        return _coin.SoCylinderDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCylinderDetail_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoCylinderDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoCylinderDetail self) -> SoCylinderDetail"""
        _coin.SoCylinderDetail_swiginit(self, _coin.new_SoCylinderDetail())
    __swig_destroy__ = _coin.delete_SoCylinderDetail

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCylinderDetail_initClass()

    def copy(self):
        r"""copy(SoCylinderDetail self) -> SoDetail"""
        return _coin.SoCylinderDetail_copy(self)

    def setPart(self, part):
        r"""setPart(SoCylinderDetail self, int const part)"""
        return _coin.SoCylinderDetail_setPart(self, part)

    def getPart(self):
        r"""getPart(SoCylinderDetail self) -> int"""
        return _coin.SoCylinderDetail_getPart(self)

# Register SoCylinderDetail in _coin:
_coin.SoCylinderDetail_swigregister(SoCylinderDetail)
class SoPointDetail(SoDetail):
    r"""Proxy of C++ SoPointDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoPointDetail self) -> SoType"""
        return _coin.SoPointDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointDetail_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoPointDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoPointDetail self) -> SoPointDetail"""
        _coin.SoPointDetail_swiginit(self, _coin.new_SoPointDetail())
    __swig_destroy__ = _coin.delete_SoPointDetail

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPointDetail_initClass()

    def copy(self):
        r"""copy(SoPointDetail self) -> SoDetail"""
        return _coin.SoPointDetail_copy(self)

    def getCoordinateIndex(self):
        r"""getCoordinateIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getCoordinateIndex(self)

    def getMaterialIndex(self):
        r"""getMaterialIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getMaterialIndex(self)

    def getNormalIndex(self):
        r"""getNormalIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getNormalIndex(self)

    def getTextureCoordIndex(self):
        r"""getTextureCoordIndex(SoPointDetail self) -> int"""
        return _coin.SoPointDetail_getTextureCoordIndex(self)

    def setCoordinateIndex(self, idx):
        r"""setCoordinateIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setCoordinateIndex(self, idx)

    def setMaterialIndex(self, idx):
        r"""setMaterialIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setMaterialIndex(self, idx)

    def setNormalIndex(self, idx):
        r"""setNormalIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setNormalIndex(self, idx)

    def setTextureCoordIndex(self, idx):
        r"""setTextureCoordIndex(SoPointDetail self, int const idx)"""
        return _coin.SoPointDetail_setTextureCoordIndex(self, idx)

# Register SoPointDetail in _coin:
_coin.SoPointDetail_swigregister(SoPointDetail)
class SoFaceDetail(SoDetail):
    r"""Proxy of C++ SoFaceDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoFaceDetail self) -> SoType"""
        return _coin.SoFaceDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFaceDetail_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoFaceDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoFaceDetail self) -> SoFaceDetail"""
        _coin.SoFaceDetail_swiginit(self, _coin.new_SoFaceDetail())
    __swig_destroy__ = _coin.delete_SoFaceDetail

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFaceDetail_initClass()

    def copy(self):
        r"""copy(SoFaceDetail self) -> SoDetail"""
        return _coin.SoFaceDetail_copy(self)

    def getNumPoints(self):
        r"""getNumPoints(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getNumPoints(self)

    def getPoint(self, idx):
        r"""getPoint(SoFaceDetail self, int const idx) -> SoPointDetail"""
        return _coin.SoFaceDetail_getPoint(self, idx)

    def getPoints(self):
        r"""getPoints(SoFaceDetail self) -> SoPointDetail"""
        return _coin.SoFaceDetail_getPoints(self)

    def getFaceIndex(self):
        r"""getFaceIndex(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getFaceIndex(self)

    def getPartIndex(self):
        r"""getPartIndex(SoFaceDetail self) -> int"""
        return _coin.SoFaceDetail_getPartIndex(self)

    def setNumPoints(self, num):
        r"""setNumPoints(SoFaceDetail self, int const num)"""
        return _coin.SoFaceDetail_setNumPoints(self, num)

    def setPoint(self, idx, detail):
        r"""setPoint(SoFaceDetail self, int const idx, SoPointDetail detail)"""
        return _coin.SoFaceDetail_setPoint(self, idx, detail)

    def setFaceIndex(self, idx):
        r"""setFaceIndex(SoFaceDetail self, int const idx)"""
        return _coin.SoFaceDetail_setFaceIndex(self, idx)

    def setPartIndex(self, idx):
        r"""setPartIndex(SoFaceDetail self, int const idx)"""
        return _coin.SoFaceDetail_setPartIndex(self, idx)

    def incFaceIndex(self):
        r"""incFaceIndex(SoFaceDetail self)"""
        return _coin.SoFaceDetail_incFaceIndex(self)

    def incPartIndex(self):
        r"""incPartIndex(SoFaceDetail self)"""
        return _coin.SoFaceDetail_incPartIndex(self)

# Register SoFaceDetail in _coin:
_coin.SoFaceDetail_swigregister(SoFaceDetail)
class SoLineDetail(SoDetail):
    r"""Proxy of C++ SoLineDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoLineDetail self) -> SoType"""
        return _coin.SoLineDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLineDetail_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoLineDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoLineDetail self) -> SoLineDetail"""
        _coin.SoLineDetail_swiginit(self, _coin.new_SoLineDetail())
    __swig_destroy__ = _coin.delete_SoLineDetail

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLineDetail_initClass()

    def copy(self):
        r"""copy(SoLineDetail self) -> SoDetail"""
        return _coin.SoLineDetail_copy(self)

    def getPoint0(self):
        r"""getPoint0(SoLineDetail self) -> SoPointDetail"""
        return _coin.SoLineDetail_getPoint0(self)

    def getPoint1(self):
        r"""getPoint1(SoLineDetail self) -> SoPointDetail"""
        return _coin.SoLineDetail_getPoint1(self)

    def getLineIndex(self):
        r"""getLineIndex(SoLineDetail self) -> int"""
        return _coin.SoLineDetail_getLineIndex(self)

    def getPartIndex(self):
        r"""getPartIndex(SoLineDetail self) -> int"""
        return _coin.SoLineDetail_getPartIndex(self)

    def setPoint0(self, detail):
        r"""setPoint0(SoLineDetail self, SoPointDetail detail)"""
        return _coin.SoLineDetail_setPoint0(self, detail)

    def setPoint1(self, detail):
        r"""setPoint1(SoLineDetail self, SoPointDetail detail)"""
        return _coin.SoLineDetail_setPoint1(self, detail)

    def setLineIndex(self, idx):
        r"""setLineIndex(SoLineDetail self, int const idx)"""
        return _coin.SoLineDetail_setLineIndex(self, idx)

    def setPartIndex(self, idx):
        r"""setPartIndex(SoLineDetail self, int const idx)"""
        return _coin.SoLineDetail_setPartIndex(self, idx)

    def incLineIndex(self):
        r"""incLineIndex(SoLineDetail self)"""
        return _coin.SoLineDetail_incLineIndex(self)

    def incPartIndex(self):
        r"""incPartIndex(SoLineDetail self)"""
        return _coin.SoLineDetail_incPartIndex(self)

# Register SoLineDetail in _coin:
_coin.SoLineDetail_swigregister(SoLineDetail)
class SoNodeKitDetail(SoDetail):
    r"""Proxy of C++ SoNodeKitDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoNodeKitDetail self) -> SoType"""
        return _coin.SoNodeKitDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNodeKitDetail_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoNodeKitDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoNodeKitDetail self) -> SoNodeKitDetail"""
        _coin.SoNodeKitDetail_swiginit(self, _coin.new_SoNodeKitDetail())
    __swig_destroy__ = _coin.delete_SoNodeKitDetail

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNodeKitDetail_initClass()

    def copy(self):
        r"""copy(SoNodeKitDetail self) -> SoDetail"""
        return _coin.SoNodeKitDetail_copy(self)

    def setNodeKit(self, kit):
        r"""setNodeKit(SoNodeKitDetail self, SoBaseKit kit)"""
        return _coin.SoNodeKitDetail_setNodeKit(self, kit)

    def getNodeKit(self):
        r"""getNodeKit(SoNodeKitDetail self) -> SoBaseKit"""
        return _coin.SoNodeKitDetail_getNodeKit(self)

    def setPart(self, part):
        r"""setPart(SoNodeKitDetail self, SoNode part)"""
        return _coin.SoNodeKitDetail_setPart(self, part)

    def getPart(self):
        r"""getPart(SoNodeKitDetail self) -> SoNode"""
        return _coin.SoNodeKitDetail_getPart(self)

    def setPartName(self, name):
        r"""setPartName(SoNodeKitDetail self, SbName name)"""
        return _coin.SoNodeKitDetail_setPartName(self, name)

    def getPartName(self):
        r"""getPartName(SoNodeKitDetail self) -> SbName"""
        return _coin.SoNodeKitDetail_getPartName(self)

# Register SoNodeKitDetail in _coin:
_coin.SoNodeKitDetail_swigregister(SoNodeKitDetail)
class SoTextDetail(SoDetail):
    r"""Proxy of C++ SoTextDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def getTypeId(self):
        r"""getTypeId(SoTextDetail self) -> SoType"""
        return _coin.SoTextDetail_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextDetail_getClassTypeId()

    @staticmethod
    def cleanupClass():
        r"""cleanupClass()"""
        return _coin.SoTextDetail_cleanupClass()

    def __init__(self):
        r"""__init__(SoTextDetail self) -> SoTextDetail"""
        _coin.SoTextDetail_swiginit(self, _coin.new_SoTextDetail())
    __swig_destroy__ = _coin.delete_SoTextDetail

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextDetail_initClass()

    def copy(self):
        r"""copy(SoTextDetail self) -> SoDetail"""
        return _coin.SoTextDetail_copy(self)

    def getStringIndex(self):
        r"""getStringIndex(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getStringIndex(self)

    def getCharacterIndex(self):
        r"""getCharacterIndex(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getCharacterIndex(self)

    def getPart(self):
        r"""getPart(SoTextDetail self) -> int"""
        return _coin.SoTextDetail_getPart(self)

    def setStringIndex(self, idx):
        r"""setStringIndex(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setStringIndex(self, idx)

    def setCharacterIndex(self, idx):
        r"""setCharacterIndex(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setCharacterIndex(self, idx)

    def setPart(self, idx):
        r"""setPart(SoTextDetail self, int const idx)"""
        return _coin.SoTextDetail_setPart(self, idx)

# Register SoTextDetail in _coin:
_coin.SoTextDetail_swigregister(SoTextDetail)
class SoSFNode(SoSField):
    r"""Proxy of C++ SoSFNode class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFNode self) -> SoSFNode"""
        _coin.SoSFNode_swiginit(self, _coin.new_SoSFNode())
    __swig_destroy__ = _coin.delete_SoSFNode

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFNode_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFNode_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFNode self) -> SoType"""
        return _coin.SoSFNode_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFNode self, SoField field)"""
        return _coin.SoSFNode_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFNode self, SoField field) -> SbBool"""
        return _coin.SoSFNode_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFNode self) -> SoNode"""
        return _coin.SoSFNode_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFNode self, SoSFNode field) -> int"""
        return _coin.SoSFNode___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFNode self, SoSFNode field) -> int"""
        return _coin.SoSFNode___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFNode_initClass()

    def fixCopy(self, copyconnections):
        r"""fixCopy(SoSFNode self, SbBool copyconnections)"""
        return _coin.SoSFNode_fixCopy(self, copyconnections)

    def referencesCopy(self):
        r"""referencesCopy(SoSFNode self) -> SbBool"""
        return _coin.SoSFNode_referencesCopy(self)

    def setValue(self, *args):
        r"""
        setValue(SoSFNode self, SoNode newvalue)
        setValue(SoSFNode self, SoSFNode other)
        """
        return _coin.SoSFNode_setValue(self, *args)

# Register SoSFNode in _coin:
_coin.SoSFNode_swigregister(SoSFNode)
SO_CATALOG_NAME_NOT_FOUND = _coin.SO_CATALOG_NAME_NOT_FOUND

class SoNodekitCatalog(object):
    r"""Proxy of C++ SoNodekitCatalog class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNodekitCatalog_initClass()

    def __init__(self):
        r"""__init__(SoNodekitCatalog self) -> SoNodekitCatalog"""
        _coin.SoNodekitCatalog_swiginit(self, _coin.new_SoNodekitCatalog())
    __swig_destroy__ = _coin.delete_SoNodekitCatalog

    def getNumEntries(self):
        r"""getNumEntries(SoNodekitCatalog self) -> int"""
        return _coin.SoNodekitCatalog_getNumEntries(self)

    def getPartNumber(self, name):
        r"""getPartNumber(SoNodekitCatalog self, SbName name) -> int"""
        return _coin.SoNodekitCatalog_getPartNumber(self, name)

    def getName(self, part):
        r"""getName(SoNodekitCatalog self, int part) -> SbName"""
        return _coin.SoNodekitCatalog_getName(self, part)

    def getType(self, *args):
        r"""
        getType(SoNodekitCatalog self, int part) -> SoType
        getType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getType(self, *args)

    def getDefaultType(self, *args):
        r"""
        getDefaultType(SoNodekitCatalog self, int part) -> SoType
        getDefaultType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getDefaultType(self, *args)

    def isNullByDefault(self, *args):
        r"""
        isNullByDefault(SoNodekitCatalog self, int part) -> SbBool
        isNullByDefault(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isNullByDefault(self, *args)

    def isLeaf(self, *args):
        r"""
        isLeaf(SoNodekitCatalog self, int part) -> SbBool
        isLeaf(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isLeaf(self, *args)

    def getParentName(self, *args):
        r"""
        getParentName(SoNodekitCatalog self, int part) -> SbName
        getParentName(SoNodekitCatalog self, SbName name) -> SbName
        """
        return _coin.SoNodekitCatalog_getParentName(self, *args)

    def getParentPartNumber(self, *args):
        r"""
        getParentPartNumber(SoNodekitCatalog self, int part) -> int
        getParentPartNumber(SoNodekitCatalog self, SbName name) -> int
        """
        return _coin.SoNodekitCatalog_getParentPartNumber(self, *args)

    def getRightSiblingName(self, *args):
        r"""
        getRightSiblingName(SoNodekitCatalog self, int part) -> SbName
        getRightSiblingName(SoNodekitCatalog self, SbName name) -> SbName
        """
        return _coin.SoNodekitCatalog_getRightSiblingName(self, *args)

    def getRightSiblingPartNumber(self, *args):
        r"""
        getRightSiblingPartNumber(SoNodekitCatalog self, int part) -> int
        getRightSiblingPartNumber(SoNodekitCatalog self, SbName name) -> int
        """
        return _coin.SoNodekitCatalog_getRightSiblingPartNumber(self, *args)

    def isList(self, *args):
        r"""
        isList(SoNodekitCatalog self, int part) -> SbBool
        isList(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isList(self, *args)

    def getListContainerType(self, *args):
        r"""
        getListContainerType(SoNodekitCatalog self, int part) -> SoType
        getListContainerType(SoNodekitCatalog self, SbName name) -> SoType
        """
        return _coin.SoNodekitCatalog_getListContainerType(self, *args)

    def getListItemTypes(self, *args):
        r"""
        getListItemTypes(SoNodekitCatalog self, int part) -> SoTypeList
        getListItemTypes(SoNodekitCatalog self, SbName name) -> SoTypeList
        """
        return _coin.SoNodekitCatalog_getListItemTypes(self, *args)

    def isPublic(self, *args):
        r"""
        isPublic(SoNodekitCatalog self, int part) -> SbBool
        isPublic(SoNodekitCatalog self, SbName name) -> SbBool
        """
        return _coin.SoNodekitCatalog_isPublic(self, *args)

    def clone(self, type):
        r"""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):
        r"""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):
        r"""
        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):
        r"""narrowTypes(SoNodekitCatalog self, SbName name, SoType newtype, SoType newdefaulttype)"""
        return _coin.SoNodekitCatalog_narrowTypes(self, name, newtype, newdefaulttype)

    def setNullByDefault(self, name, nullbydefault):
        r"""setNullByDefault(SoNodekitCatalog self, SbName name, SbBool nullbydefault)"""
        return _coin.SoNodekitCatalog_setNullByDefault(self, name, nullbydefault)

    def recursiveSearch(self, part, name, checked):
        r"""recursiveSearch(SoNodekitCatalog self, int part, SbName name, SoTypeList checked) -> SbBool"""
        return _coin.SoNodekitCatalog_recursiveSearch(self, part, name, checked)

    def printCheck(self):
        r"""printCheck(SoNodekitCatalog self)"""
        return _coin.SoNodekitCatalog_printCheck(self)

# Register SoNodekitCatalog in _coin:
_coin.SoNodekitCatalog_swigregister(SoNodekitCatalog)
class SoSFName(SoSField):
    r"""Proxy of C++ SoSFName class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFName self) -> SoSFName"""
        _coin.SoSFName_swiginit(self, _coin.new_SoSFName())
    __swig_destroy__ = _coin.delete_SoSFName

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFName_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFName_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFName self) -> SoType"""
        return _coin.SoSFName_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFName self, SoField field)"""
        return _coin.SoSFName_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFName self, SoField field) -> SbBool"""
        return _coin.SoSFName_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFName self) -> SbName"""
        return _coin.SoSFName_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFName self, SoSFName field) -> int"""
        return _coin.SoSFName___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFName self, SoSFName field) -> int"""
        return _coin.SoSFName___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFName_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFName self, SbName newvalue)
        setValue(SoSFName self, char const *const name)
        setValue(SoSFName self, SoSFName other)
        """
        return _coin.SoSFName_setValue(self, *args)

# Register SoSFName in _coin:
_coin.SoSFName_swigregister(SoSFName)
class SoMFName(SoMField):
    r"""Proxy of C++ SoMFName class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFName self) -> SoMFName"""
        _coin.SoMFName_swiginit(self, _coin.new_SoMFName())
    __swig_destroy__ = _coin.delete_SoMFName

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFName_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFName_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFName self) -> SoType"""
        return _coin.SoMFName_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFName self, SoField field)"""
        return _coin.SoMFName_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFName self, SoField field) -> SbBool"""
        return _coin.SoMFName_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFName self, SbName value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFName_find(self, value, addifnotfound)

    def set1Value(self, idx, value):
        r"""set1Value(SoMFName self, int const idx, SbName value)"""
        return _coin.SoMFName_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFName self, SoMFName field) -> SbBool"""
        return _coin.SoMFName___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFName self, SoMFName field) -> SbBool"""
        return _coin.SoMFName___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFName self) -> SbName"""
        return _coin.SoMFName_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFName self)"""
        return _coin.SoMFName_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFName_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 _coin.SoMFName_setValues(*args)



    def __getitem__(self, i):
        r"""__getitem__(SoMFName self, int i) -> SbName"""
        return _coin.SoMFName___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFName self, int i, SbName value)"""
        return _coin.SoMFName___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        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):
        r"""getValues(SoMFName self, int i=0) -> SbName"""
        return _coin.SoMFName_getValues(self, i)

# Register SoMFName in _coin:
_coin.SoMFName_swigregister(SoMFName)
class SoNodeKitListPart(SoNode):
    r"""Proxy of C++ SoNodeKitListPart class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNodeKitListPart_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoNodeKitListPart self) -> SoType"""
        return _coin.SoNodeKitListPart_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNodeKitListPart_initClass()

    def __init__(self):
        r"""__init__(SoNodeKitListPart self) -> SoNodeKitListPart"""
        _coin.SoNodeKitListPart_swiginit(self, _coin.new_SoNodeKitListPart())

    def getContainerType(self):
        r"""getContainerType(SoNodeKitListPart self) -> SoType"""
        return _coin.SoNodeKitListPart_getContainerType(self)

    def setContainerType(self, newContainerType):
        r"""setContainerType(SoNodeKitListPart self, SoType newContainerType)"""
        return _coin.SoNodeKitListPart_setContainerType(self, newContainerType)

    def getChildTypes(self):
        r"""getChildTypes(SoNodeKitListPart self) -> SoTypeList"""
        return _coin.SoNodeKitListPart_getChildTypes(self)

    def addChildType(self, typeToAdd):
        r"""addChildType(SoNodeKitListPart self, SoType typeToAdd)"""
        return _coin.SoNodeKitListPart_addChildType(self, typeToAdd)

    def isTypePermitted(self, typeToCheck):
        r"""isTypePermitted(SoNodeKitListPart self, SoType typeToCheck) -> SbBool"""
        return _coin.SoNodeKitListPart_isTypePermitted(self, typeToCheck)

    def isChildPermitted(self, child):
        r"""isChildPermitted(SoNodeKitListPart self, SoNode child) -> SbBool"""
        return _coin.SoNodeKitListPart_isChildPermitted(self, child)

    def containerSet(self, fieldDataString):
        r"""containerSet(SoNodeKitListPart self, char const * fieldDataString)"""
        return _coin.SoNodeKitListPart_containerSet(self, fieldDataString)

    def lockTypes(self):
        r"""lockTypes(SoNodeKitListPart self)"""
        return _coin.SoNodeKitListPart_lockTypes(self)

    def isTypeLocked(self):
        r"""isTypeLocked(SoNodeKitListPart self) -> SbBool"""
        return _coin.SoNodeKitListPart_isTypeLocked(self)

    def addChild(self, child):
        r"""addChild(SoNodeKitListPart self, SoNode child)"""
        return _coin.SoNodeKitListPart_addChild(self, child)

    def insertChild(self, child, childIndex):
        r"""insertChild(SoNodeKitListPart self, SoNode child, int childIndex)"""
        return _coin.SoNodeKitListPart_insertChild(self, child, childIndex)

    def getChild(self, index):
        r"""getChild(SoNodeKitListPart self, int index) -> SoNode"""
        return _coin.SoNodeKitListPart_getChild(self, index)

    def findChild(self, child):
        r"""findChild(SoNodeKitListPart self, SoNode child) -> int"""
        return _coin.SoNodeKitListPart_findChild(self, child)

    def getNumChildren(self):
        r"""getNumChildren(SoNodeKitListPart self) -> int"""
        return _coin.SoNodeKitListPart_getNumChildren(self)

    def removeChild(self, *args):
        r"""
        removeChild(SoNodeKitListPart self, int index)
        removeChild(SoNodeKitListPart self, SoNode child)
        """
        return _coin.SoNodeKitListPart_removeChild(self, *args)

    def replaceChild(self, *args):
        r"""
        replaceChild(SoNodeKitListPart self, int index, SoNode newChild)
        replaceChild(SoNodeKitListPart self, SoNode oldChild, SoNode newChild)
        """
        return _coin.SoNodeKitListPart_replaceChild(self, *args)

    def affectsState(self):
        r"""affectsState(SoNodeKitListPart self) -> SbBool"""
        return _coin.SoNodeKitListPart_affectsState(self)

    def doAction(self, action):
        r"""doAction(SoNodeKitListPart self, SoAction action)"""
        return _coin.SoNodeKitListPart_doAction(self, action)

    def callback(self, action):
        r"""callback(SoNodeKitListPart self, SoCallbackAction action)"""
        return _coin.SoNodeKitListPart_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoNodeKitListPart self, SoGLRenderAction action)"""
        return _coin.SoNodeKitListPart_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoNodeKitListPart self, SoGetBoundingBoxAction action)"""
        return _coin.SoNodeKitListPart_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoNodeKitListPart self, SoGetMatrixAction action)"""
        return _coin.SoNodeKitListPart_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoNodeKitListPart self, SoHandleEventAction action)"""
        return _coin.SoNodeKitListPart_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoNodeKitListPart self, SoPickAction action)"""
        return _coin.SoNodeKitListPart_pick(self, action)

    def search(self, action):
        r"""search(SoNodeKitListPart self, SoSearchAction action)"""
        return _coin.SoNodeKitListPart_search(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoNodeKitListPart self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNodeKitListPart_getPrimitiveCount(self, action)

    def getChildren(self):
        r"""getChildren(SoNodeKitListPart self) -> SoChildList"""
        return _coin.SoNodeKitListPart_getChildren(self)

# Register SoNodeKitListPart in _coin:
_coin.SoNodeKitListPart_swigregister(SoNodeKitListPart)
class SoNodeKitPath(SoPath):
    r"""Proxy of C++ SoNodeKitPath class."""

    thisown = property(lambda x: x.this.own(), lambda 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):
        r"""getLength(SoNodeKitPath self) -> int"""
        return _coin.SoNodeKitPath_getLength(self)

    def getTail(self):
        r"""getTail(SoNodeKitPath self) -> SoNode"""
        return _coin.SoNodeKitPath_getTail(self)

    def getNode(self, idx):
        r"""getNode(SoNodeKitPath self, int const idx) -> SoNode"""
        return _coin.SoNodeKitPath_getNode(self, idx)

    def getNodeFromTail(self, idx):
        r"""getNodeFromTail(SoNodeKitPath self, int const idx) -> SoNode"""
        return _coin.SoNodeKitPath_getNodeFromTail(self, idx)

    def truncate(self, length):
        r"""truncate(SoNodeKitPath self, int const length)"""
        return _coin.SoNodeKitPath_truncate(self, length)

    def pop(self):
        r"""pop(SoNodeKitPath self)"""
        return _coin.SoNodeKitPath_pop(self)

    def append(self, *args):
        r"""
        append(SoNodeKitPath self, SoBaseKit childKit)
        append(SoNodeKitPath self, SoNodeKitPath fromPath)
        """
        return _coin.SoNodeKitPath_append(self, *args)

    def containsNode(self, node):
        r"""containsNode(SoNodeKitPath self, SoBaseKit node) -> SbBool"""
        return _coin.SoNodeKitPath_containsNode(self, node)

    def findFork(self, path):
        r"""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):
        r"""__eq__(SoNodeKitPath self, SoNodeKitPath u) -> int"""
        return _coin.SoNodeKitPath___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SoNodeKitPath self, SoNodeKitPath u) -> int"""
        return _coin.SoNodeKitPath___nq__(self, u)

# Register SoNodeKitPath in _coin:
_coin.SoNodeKitPath_swigregister(SoNodeKitPath)
class SoChildList(SoNodeList):
    r"""Proxy of C++ SoChildList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoChildList self, SoNode parent) -> SoChildList
        __init__(SoChildList self, SoNode parent, int const size) -> SoChildList
        __init__(SoChildList self, SoNode parent, SoChildList cl) -> SoChildList
        """
        _coin.SoChildList_swiginit(self, _coin.new_SoChildList(*args))
    __swig_destroy__ = _coin.delete_SoChildList

    def append(self, node):
        r"""append(SoChildList self, SoNode node)"""
        return _coin.SoChildList_append(self, node)

    def insert(self, ptr, addbefore):
        r"""insert(SoChildList self, SoNode ptr, int const addbefore)"""
        return _coin.SoChildList_insert(self, ptr, addbefore)

    def remove(self, index):
        r"""remove(SoChildList self, int const index)"""
        return _coin.SoChildList_remove(self, index)

    def truncate(self, length):
        r"""truncate(SoChildList self, int const length)"""
        return _coin.SoChildList_truncate(self, length)

    def copy(self, cl):
        r"""copy(SoChildList self, SoChildList cl)"""
        return _coin.SoChildList_copy(self, cl)

    def set(self, index, node):
        r"""set(SoChildList self, int const index, SoNode node)"""
        return _coin.SoChildList_set(self, index, node)

    def traverseInPath(self, action, numindices, indices):
        r"""traverseInPath(SoChildList self, SoAction action, int const numindices, int const * indices)"""
        return _coin.SoChildList_traverseInPath(self, action, numindices, indices)

    def traverse(self, *args):
        r"""
        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):
        r"""addPathAuditor(SoChildList self, SoPath path)"""
        return _coin.SoChildList_addPathAuditor(self, path)

    def removePathAuditor(self, path):
        r"""removePathAuditor(SoChildList self, SoPath path)"""
        return _coin.SoChildList_removePathAuditor(self, path)

# Register SoChildList in _coin:
_coin.SoChildList_swigregister(SoChildList)
class SoBaseKit(SoNode):
    r"""Proxy of C++ SoBaseKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBaseKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoBaseKit self) -> SoType"""
        return _coin.SoBaseKit_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBaseKit_initClass()

    def __init__(self):
        r"""__init__(SoBaseKit self) -> SoBaseKit"""
        _coin.SoBaseKit_swiginit(self, _coin.new_SoBaseKit())

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoBaseKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoBaseKit self) -> SoNodekitCatalog"""
        return _coin.SoBaseKit_getNodekitCatalog(self)

    def getPart(self, partname, makeifneeded):
        r"""getPart(SoBaseKit self, SbName partname, SbBool makeifneeded) -> SoNode"""
        return _coin.SoBaseKit_getPart(self, partname, makeifneeded)

    def getPartString(self, part):
        r"""getPartString(SoBaseKit self, SoBase part) -> SbString"""
        return _coin.SoBaseKit_getPartString(self, part)

    def createPathToPart(self, partname, makeifneeded, pathtoextend=None):
        r"""createPathToPart(SoBaseKit self, SbName partname, SbBool makeifneeded, SoPath pathtoextend=None) -> SoNodeKitPath"""
        return _coin.SoBaseKit_createPathToPart(self, partname, makeifneeded, pathtoextend)

    def setPart(self, partname, srcFrom):
        r"""setPart(SoBaseKit self, SbName partname, SoNode srcFrom) -> SbBool"""
        return _coin.SoBaseKit_setPart(self, partname, srcFrom)

    def set(self, *args):
        r"""
        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):
        r"""doAction(SoBaseKit self, SoAction action)"""
        return _coin.SoBaseKit_doAction(self, action)

    def callback(self, action):
        r"""callback(SoBaseKit self, SoCallbackAction action)"""
        return _coin.SoBaseKit_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoBaseKit self, SoGLRenderAction action)"""
        return _coin.SoBaseKit_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoBaseKit self, SoGetBoundingBoxAction action)"""
        return _coin.SoBaseKit_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoBaseKit self, SoGetMatrixAction action)"""
        return _coin.SoBaseKit_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoBaseKit self, SoHandleEventAction action)"""
        return _coin.SoBaseKit_handleEvent(self, action)

    def rayPick(self, action):
        r"""rayPick(SoBaseKit self, SoRayPickAction action)"""
        return _coin.SoBaseKit_rayPick(self, action)

    def search(self, action):
        r"""search(SoBaseKit self, SoSearchAction action)"""
        return _coin.SoBaseKit_search(self, action)

    def write(self, action):
        r"""write(SoBaseKit self, SoWriteAction action)"""
        return _coin.SoBaseKit_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoBaseKit self, SoGetPrimitiveCountAction action)"""
        return _coin.SoBaseKit_getPrimitiveCount(self, action)

    def getChildren(self):
        r"""getChildren(SoBaseKit self) -> SoChildList"""
        return _coin.SoBaseKit_getChildren(self)

    def printDiagram(self):
        r"""printDiagram(SoBaseKit self)"""
        return _coin.SoBaseKit_printDiagram(self)

    def printSubDiagram(self, rootname, level):
        r"""printSubDiagram(SoBaseKit self, SbName rootname, int level)"""
        return _coin.SoBaseKit_printSubDiagram(self, rootname, level)

    def printTable(self):
        r"""printTable(SoBaseKit self)"""
        return _coin.SoBaseKit_printTable(self)

    def addWriteReference(self, out, isfromfield=0):
        r"""addWriteReference(SoBaseKit self, SoOutput out, SbBool isfromfield=0)"""
        return _coin.SoBaseKit_addWriteReference(self, out, isfromfield)

    def forceChildDrivenWriteRefs(self, out):
        r"""forceChildDrivenWriteRefs(SoBaseKit self, SoOutput out) -> SbBool"""
        return _coin.SoBaseKit_forceChildDrivenWriteRefs(self, out)

    @staticmethod
    def isSearchingChildren():
        r"""isSearchingChildren() -> SbBool"""
        return _coin.SoBaseKit_isSearchingChildren()

    @staticmethod
    def setSearchingChildren(newval):
        r"""setSearchingChildren(SbBool const newval)"""
        return _coin.SoBaseKit_setSearchingChildren(newval)

    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)       


# Register SoBaseKit in _coin:
_coin.SoBaseKit_swigregister(SoBaseKit)
class SoSensor(object):
    r"""Proxy of C++ SoSensor class."""

    thisown = property(lambda x: 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

    def setFunction(self, callbackfunction):
        r"""setFunction(SoSensor self, SoSensorCB * callbackfunction)"""
        return _coin.SoSensor_setFunction(self, callbackfunction)

    def getFunction(self):
        r"""getFunction(SoSensor self) -> SoSensorCBPtr"""
        return _coin.SoSensor_getFunction(self)

    def setData(self, callbackdata):
        r"""setData(SoSensor self, void * callbackdata)"""
        return _coin.SoSensor_setData(self, callbackdata)

    def getData(self):
        r"""getData(SoSensor self) -> void *"""
        return _coin.SoSensor_getData(self)

    def schedule(self):
        r"""schedule(SoSensor self)"""
        return _coin.SoSensor_schedule(self)

    def unschedule(self):
        r"""unschedule(SoSensor self)"""
        return _coin.SoSensor_unschedule(self)

    def isScheduled(self):
        r"""isScheduled(SoSensor self) -> SbBool"""
        return _coin.SoSensor_isScheduled(self)

    def trigger(self):
        r"""trigger(SoSensor self)"""
        return _coin.SoSensor_trigger(self)

    def isBefore(self, s):
        r"""isBefore(SoSensor self, SoSensor s) -> SbBool"""
        return _coin.SoSensor_isBefore(self, s)

    def setNextInQueue(self, next):
        r"""setNextInQueue(SoSensor self, SoSensor next)"""
        return _coin.SoSensor_setNextInQueue(self, next)

    def getNextInQueue(self):
        r"""getNextInQueue(SoSensor self) -> SoSensor"""
        return _coin.SoSensor_getNextInQueue(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSensor_initClass()

# Register SoSensor in _coin:
_coin.SoSensor_swigregister(SoSensor)
class SoDelayQueueSensor(SoSensor):
    r"""Proxy of C++ SoDelayQueueSensor class."""

    thisown = 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 = _coin.new_SoDelayQueueSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoDelayQueueSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoDelayQueueSensor

    def setPriority(self, pri):
        r"""setPriority(SoDelayQueueSensor self, uint32_t pri)"""
        return _coin.SoDelayQueueSensor_setPriority(self, pri)

    def getPriority(self):
        r"""getPriority(SoDelayQueueSensor self) -> uint32_t"""
        return _coin.SoDelayQueueSensor_getPriority(self)

    @staticmethod
    def getDefaultPriority():
        r"""getDefaultPriority() -> uint32_t"""
        return _coin.SoDelayQueueSensor_getDefaultPriority()

    def schedule(self):
        r"""schedule(SoDelayQueueSensor self)"""
        return _coin.SoDelayQueueSensor_schedule(self)

    def unschedule(self):
        r"""unschedule(SoDelayQueueSensor self)"""
        return _coin.SoDelayQueueSensor_unschedule(self)

    def isScheduled(self):
        r"""isScheduled(SoDelayQueueSensor self) -> SbBool"""
        return _coin.SoDelayQueueSensor_isScheduled(self)

    def isIdleOnly(self):
        r"""isIdleOnly(SoDelayQueueSensor self) -> SbBool"""
        return _coin.SoDelayQueueSensor_isIdleOnly(self)

    def trigger(self):
        r"""trigger(SoDelayQueueSensor self)"""
        return _coin.SoDelayQueueSensor_trigger(self)

# Register SoDelayQueueSensor in _coin:
_coin.SoDelayQueueSensor_swigregister(SoDelayQueueSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoDelayQueueSensor *"))
      newobj = _coin.new_SoDelayQueueSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoDelayQueueSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoDataSensor(SoDelayQueueSensor):
    r"""Proxy of C++ SoDataSensor class."""

    thisown = property(lambda x: 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

    def setDeleteCallback(self, function, data=None):
        r"""setDeleteCallback(SoDataSensor self, SoSensorCB * function, void * data=None)"""
        return _coin.SoDataSensor_setDeleteCallback(self, function, data)

    def getTriggerNode(self):
        r"""getTriggerNode(SoDataSensor self) -> SoNode"""
        return _coin.SoDataSensor_getTriggerNode(self)

    def getTriggerField(self):
        r"""getTriggerField(SoDataSensor self) -> SoField"""
        return _coin.SoDataSensor_getTriggerField(self)

    def getTriggerPath(self):
        r"""getTriggerPath(SoDataSensor self) -> SoPath"""
        return _coin.SoDataSensor_getTriggerPath(self)

    def setTriggerPathFlag(self, flag):
        r"""setTriggerPathFlag(SoDataSensor self, SbBool flag)"""
        return _coin.SoDataSensor_setTriggerPathFlag(self, flag)

    def getTriggerPathFlag(self):
        r"""getTriggerPathFlag(SoDataSensor self) -> SbBool"""
        return _coin.SoDataSensor_getTriggerPathFlag(self)

    def trigger(self):
        r"""trigger(SoDataSensor self)"""
        return _coin.SoDataSensor_trigger(self)

    def notify(self, l):
        r"""notify(SoDataSensor self, SoNotList l)"""
        return _coin.SoDataSensor_notify(self, l)

    def dyingReference(self):
        r"""dyingReference(SoDataSensor self)"""
        return _coin.SoDataSensor_dyingReference(self)

# Register SoDataSensor in _coin:
_coin.SoDataSensor_swigregister(SoDataSensor)
class SoFieldSensor(SoDataSensor):
    r"""Proxy of C++ SoFieldSensor class."""

    thisown = 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 = _coin.new_SoFieldSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoFieldSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoFieldSensor

    def attach(self, field):
        r"""attach(SoFieldSensor self, SoField field)"""
        return _coin.SoFieldSensor_attach(self, field)

    def detach(self):
        r"""detach(SoFieldSensor self)"""
        return _coin.SoFieldSensor_detach(self)

    def getAttachedField(self):
        r"""getAttachedField(SoFieldSensor self) -> SoField"""
        return _coin.SoFieldSensor_getAttachedField(self)

    def trigger(self):
        r"""trigger(SoFieldSensor self)"""
        return _coin.SoFieldSensor_trigger(self)

# Register SoFieldSensor in _coin:
_coin.SoFieldSensor_swigregister(SoFieldSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoFieldSensor *"))
      newobj = _coin.new_SoFieldSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoFieldSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoInteractionKit(SoBaseKit):
    r"""Proxy of C++ SoInteractionKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInteractionKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoInteractionKit self) -> SoType"""
        return _coin.SoInteractionKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoInteractionKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoInteractionKit self) -> SoNodekitCatalog"""
        return _coin.SoInteractionKit_getNodekitCatalog(self)
    renderCaching = property(_coin.SoInteractionKit_renderCaching_get, _coin.SoInteractionKit_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoInteractionKit_boundingBoxCaching_get, _coin.SoInteractionKit_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")
    renderCulling = property(_coin.SoInteractionKit_renderCulling_get, _coin.SoInteractionKit_renderCulling_set, doc=r"""renderCulling : SoSFEnum""")
    pickCulling = property(_coin.SoInteractionKit_pickCulling_get, _coin.SoInteractionKit_pickCulling_set, doc=r"""pickCulling : SoSFEnum""")

    def __init__(self):
        r"""__init__(SoInteractionKit self) -> SoInteractionKit"""
        _coin.SoInteractionKit_swiginit(self, _coin.new_SoInteractionKit())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInteractionKit_initClass()
    OFF = _coin.SoInteractionKit_OFF
    
    ON = _coin.SoInteractionKit_ON
    
    AUTO = _coin.SoInteractionKit_AUTO
    

    def setPartAsPath(self, partname, path):
        r"""setPartAsPath(SoInteractionKit self, SbName partname, SoPath path) -> SbBool"""
        return _coin.SoInteractionKit_setPartAsPath(self, partname, path)

    def setPartAsDefault(self, *args):
        r"""
        setPartAsDefault(SoInteractionKit self, SbName partname, SoNode node, SbBool onlyifdefault=1) -> SbBool
        setPartAsDefault(SoInteractionKit self, SbName partname, SbName nodename, SbBool onlyifdefault=1) -> SbBool
        """
        return _coin.SoInteractionKit_setPartAsDefault(self, *args)

    def isPathSurrogateInMySubgraph(self, *args):
        r"""
        isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path, SoPath *& pathToOwner, SbName surrogatename, SoPath *& surrogatepath, SbBool fillargs=1) -> SbBool
        isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path) -> SbBool
        """
        return _coin.SoInteractionKit_isPathSurrogateInMySubgraph(self, *args)

    @staticmethod
    def setSwitchValue(node, newVal):
        r"""setSwitchValue(SoNode node, int const newVal)"""
        return _coin.SoInteractionKit_setSwitchValue(node, newVal)

    def setPart(self, partname, srcFrom):
        r"""setPart(SoInteractionKit self, SbName partname, SoNode srcFrom) -> SbBool"""
        return _coin.SoInteractionKit_setPart(self, partname, srcFrom)

# Register SoInteractionKit in _coin:
_coin.SoInteractionKit_swigregister(SoInteractionKit)
class SoCallbackList(object):
    r"""Proxy of C++ SoCallbackList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoCallbackList self) -> SoCallbackList"""
        _coin.SoCallbackList_swiginit(self, _coin.new_SoCallbackList())
    __swig_destroy__ = _coin.delete_SoCallbackList

    def addCallback(self, f, userData=None):
        r"""addCallback(SoCallbackList self, SoCallbackListCB * f, void * userData=None)"""
        return _coin.SoCallbackList_addCallback(self, f, userData)

    def removeCallback(self, f, userdata=None):
        r"""removeCallback(SoCallbackList self, SoCallbackListCB * f, void * userdata=None)"""
        return _coin.SoCallbackList_removeCallback(self, f, userdata)

    def clearCallbacks(self):
        r"""clearCallbacks(SoCallbackList self)"""
        return _coin.SoCallbackList_clearCallbacks(self)

    def getNumCallbacks(self):
        r"""getNumCallbacks(SoCallbackList self) -> int"""
        return _coin.SoCallbackList_getNumCallbacks(self)

    def invokeCallbacks(self, callbackdata):
        r"""invokeCallbacks(SoCallbackList self, void * callbackdata)"""
        return _coin.SoCallbackList_invokeCallbacks(self, callbackdata)

# Register SoCallbackList in _coin:
_coin.SoCallbackList_swigregister(SoCallbackList)
class SbVec3d(object):
    r"""Proxy of C++ SbVec3d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec3d_swiginit(self, _coin.new_SbVec3d(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""getValue(SbVec3d self) -> double const *"""
        return _coin.SbVec3d_getValue(self)

    def cross(self, v):
        r"""cross(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d_cross(self, v)

    def dot(self, v):
        r"""dot(SbVec3d self, SbVec3d v) -> double"""
        return _coin.SbVec3d_dot(self, v)

    def equals(self, v, tolerance):
        r"""equals(SbVec3d self, SbVec3d v, double tolerance) -> SbBool"""
        return _coin.SbVec3d_equals(self, v, tolerance)

    def getClosestAxis(self):
        r"""getClosestAxis(SbVec3d self) -> SbVec3d"""
        return _coin.SbVec3d_getClosestAxis(self)

    def length(self):
        r"""length(SbVec3d self) -> double"""
        return _coin.SbVec3d_length(self)

    def sqrLength(self):
        r"""sqrLength(SbVec3d self) -> double"""
        return _coin.SbVec3d_sqrLength(self)

    def negate(self):
        r"""negate(SbVec3d self)"""
        return _coin.SbVec3d_negate(self)

    def normalize(self):
        r"""normalize(SbVec3d self) -> double"""
        return _coin.SbVec3d_normalize(self)

    def __imul__(self, d):
        r"""__imul__(SbVec3d self, double d) -> SbVec3d"""
        return _coin.SbVec3d___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec3d___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec3d self, SbVec3d v) -> SbVec3d"""
        return _coin.SbVec3d___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec3d self) -> SbVec3d"""
        return _coin.SbVec3d___neg__(self)

    def output(self, fp):
        r"""output(SbVec3d self, FILE * fp)"""
        return _coin.SbVec3d_output(self, fp)

    def __add__(self, u):
        r"""__add__(SbVec3d self, SbVec3d u) -> SbVec3d"""
        return _coin.SbVec3d___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbVec3d self, SbVec3d u) -> SbVec3d"""
        return _coin.SbVec3d___sub__(self, u)

    def __mul__(self, *args):
        r"""
        __mul__(SbVec3d self, double const d) -> SbVec3d
        __mul__(SbVec3d self, SbDPMatrix m) -> SbVec3d
        """
        return _coin.SbVec3d___mul__(self, *args)

    def __rmul__(self, d):
        r"""__rmul__(SbVec3d self, double const d) -> SbVec3d"""
        return _coin.SbVec3d___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbVec3d self, double const d) -> SbVec3d"""
        return _coin.SbVec3d___div__(self, d)

    def __truediv__(self, d):
        r"""__truediv__(SbVec3d self, double const d) -> SbVec3d"""
        return _coin.SbVec3d___truediv__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbVec3d self, SbVec3d u) -> int"""
        return _coin.SbVec3d___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbVec3d self, SbVec3d u) -> int"""
        return _coin.SbVec3d___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbVec3d self, int i) -> double"""
        return _coin.SbVec3d___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__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

# Register SbVec3d in _coin:
_coin.SbVec3d_swigregister(SbVec3d)
class SbDPViewVolume(object):
    r"""Proxy of C++ SbDPViewVolume class."""

    thisown = 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):
        r"""__init__(SbDPViewVolume self) -> SbDPViewVolume"""
        _coin.SbDPViewVolume_swiginit(self, _coin.new_SbDPViewVolume())
    __swig_destroy__ = _coin.delete_SbDPViewVolume

    def getMatrices(self, affine, proj):
        r"""getMatrices(SbDPViewVolume self, SbDPMatrix affine, SbDPMatrix proj)"""
        return _coin.SbDPViewVolume_getMatrices(self, affine, proj)

    def getMatrix(self):
        r"""getMatrix(SbDPViewVolume self) -> SbDPMatrix"""
        return _coin.SbDPViewVolume_getMatrix(self)

    def getCameraSpaceMatrix(self):
        r"""getCameraSpaceMatrix(SbDPViewVolume self) -> SbDPMatrix"""
        return _coin.SbDPViewVolume_getCameraSpaceMatrix(self)

    def projectPointToLine(self, *args):
        r"""
        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):
        r"""projectToScreen(SbDPViewVolume self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPViewVolume_projectToScreen(self, src, dst)

    def getPlane(self, distFromEye):
        r"""getPlane(SbDPViewVolume self, double const distFromEye) -> SbPlane"""
        return _coin.SbDPViewVolume_getPlane(self, distFromEye)

    def getSightPoint(self, distFromEye):
        r"""getSightPoint(SbDPViewVolume self, double const distFromEye) -> SbVec3d"""
        return _coin.SbDPViewVolume_getSightPoint(self, distFromEye)

    def getPlanePoint(self, distFromEye, normPoint):
        r"""getPlanePoint(SbDPViewVolume self, double const distFromEye, SbVec2d normPoint) -> SbVec3d"""
        return _coin.SbDPViewVolume_getPlanePoint(self, distFromEye, normPoint)

    def getAlignRotation(self, rightAngleOnly=0):
        r"""getAlignRotation(SbDPViewVolume self, SbBool rightAngleOnly=0) -> SbDPRotation"""
        return _coin.SbDPViewVolume_getAlignRotation(self, rightAngleOnly)

    def getWorldToScreenScale(self, worldCenter, normRadius):
        r"""getWorldToScreenScale(SbDPViewVolume self, SbVec3d worldCenter, double normRadius) -> double"""
        return _coin.SbDPViewVolume_getWorldToScreenScale(self, worldCenter, normRadius)

    def projectBox(self, box):
        r"""projectBox(SbDPViewVolume self, SbBox3f box) -> SbVec2d"""
        return _coin.SbDPViewVolume_projectBox(self, box)

    def narrow(self, *args):
        r"""
        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):
        r"""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):
        r"""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):
        r"""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):
        r"""rotateCamera(SbDPViewVolume self, SbDPRotation q)"""
        return _coin.SbDPViewVolume_rotateCamera(self, q)

    def translateCamera(self, v):
        r"""translateCamera(SbDPViewVolume self, SbVec3d v)"""
        return _coin.SbDPViewVolume_translateCamera(self, v)

    def zVector(self):
        r"""zVector(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_zVector(self)

    def zNarrow(self, nearval, farval):
        r"""zNarrow(SbDPViewVolume self, double nearval, double farval) -> SbDPViewVolume"""
        return _coin.SbDPViewVolume_zNarrow(self, nearval, farval)

    def scale(self, factor):
        r"""scale(SbDPViewVolume self, double factor)"""
        return _coin.SbDPViewVolume_scale(self, factor)

    def scaleWidth(self, ratio):
        r"""scaleWidth(SbDPViewVolume self, double ratio)"""
        return _coin.SbDPViewVolume_scaleWidth(self, ratio)

    def scaleHeight(self, ratio):
        r"""scaleHeight(SbDPViewVolume self, double ratio)"""
        return _coin.SbDPViewVolume_scaleHeight(self, ratio)

    def getProjectionType(self):
        r"""getProjectionType(SbDPViewVolume self) -> SbDPViewVolume::ProjectionType"""
        return _coin.SbDPViewVolume_getProjectionType(self)

    def getProjectionPoint(self):
        r"""getProjectionPoint(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getProjectionPoint(self)

    def getProjectionDirection(self):
        r"""getProjectionDirection(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getProjectionDirection(self)

    def getNearDist(self):
        r"""getNearDist(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getNearDist(self)

    def getWidth(self):
        r"""getWidth(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getWidth(self)

    def getHeight(self):
        r"""getHeight(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getHeight(self)

    def getDepth(self):
        r"""getDepth(SbDPViewVolume self) -> double"""
        return _coin.SbDPViewVolume_getDepth(self)

    def output(self, fp):
        r"""output(SbDPViewVolume self, FILE * fp)"""
        return _coin.SbDPViewVolume_output(self, fp)

    def getViewVolumePlanes(self, planes):
        r"""getViewVolumePlanes(SbDPViewVolume self, SbPlane planes)"""
        return _coin.SbDPViewVolume_getViewVolumePlanes(self, planes)

    def transform(self, matrix):
        r"""transform(SbDPViewVolume self, SbDPMatrix matrix)"""
        return _coin.SbDPViewVolume_transform(self, matrix)

    def getViewUp(self):
        r"""getViewUp(SbDPViewVolume self) -> SbVec3d"""
        return _coin.SbDPViewVolume_getViewUp(self)

    def copyValues(self, vv):
        r"""copyValues(SbDPViewVolume self, SbViewVolume vv)"""
        return _coin.SbDPViewVolume_copyValues(self, vv)

# Register SbDPViewVolume in _coin:
_coin.SbDPViewVolume_swigregister(SbDPViewVolume)
class SbViewVolume(object):
    r"""Proxy of C++ SbViewVolume class."""

    thisown = 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):
        r"""__init__(SbViewVolume self) -> SbViewVolume"""
        _coin.SbViewVolume_swiginit(self, _coin.new_SbViewVolume())
    __swig_destroy__ = _coin.delete_SbViewVolume

    def getMatrices(self, affine, proj):
        r"""getMatrices(SbViewVolume self, SbMatrix affine, SbMatrix proj)"""
        return _coin.SbViewVolume_getMatrices(self, affine, proj)

    def getMatrix(self):
        r"""getMatrix(SbViewVolume self) -> SbMatrix"""
        return _coin.SbViewVolume_getMatrix(self)

    def getCameraSpaceMatrix(self):
        r"""getCameraSpaceMatrix(SbViewVolume self) -> SbMatrix"""
        return _coin.SbViewVolume_getCameraSpaceMatrix(self)

    def getPlane(self, distFromEye):
        r"""getPlane(SbViewVolume self, float const distFromEye) -> SbPlane"""
        return _coin.SbViewVolume_getPlane(self, distFromEye)

    def getSightPoint(self, distFromEye):
        r"""getSightPoint(SbViewVolume self, float const distFromEye) -> SbVec3f"""
        return _coin.SbViewVolume_getSightPoint(self, distFromEye)

    def getPlanePoint(self, distFromEye, normPoint):
        r"""getPlanePoint(SbViewVolume self, float const distFromEye, SbVec2f normPoint) -> SbVec3f"""
        return _coin.SbViewVolume_getPlanePoint(self, distFromEye, normPoint)

    def getAlignRotation(self, rightAngleOnly=0):
        r"""getAlignRotation(SbViewVolume self, SbBool rightAngleOnly=0) -> SbRotation"""
        return _coin.SbViewVolume_getAlignRotation(self, rightAngleOnly)

    def getWorldToScreenScale(self, worldCenter, normRadius):
        r"""getWorldToScreenScale(SbViewVolume self, SbVec3f worldCenter, float normRadius) -> float"""
        return _coin.SbViewVolume_getWorldToScreenScale(self, worldCenter, normRadius)

    def projectBox(self, box):
        r"""projectBox(SbViewVolume self, SbBox3f box) -> SbVec2f"""
        return _coin.SbViewVolume_projectBox(self, box)

    def narrow(self, *args):
        r"""
        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):
        r"""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):
        r"""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):
        r"""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):
        r"""rotateCamera(SbViewVolume self, SbRotation q)"""
        return _coin.SbViewVolume_rotateCamera(self, q)

    def translateCamera(self, v):
        r"""translateCamera(SbViewVolume self, SbVec3f v)"""
        return _coin.SbViewVolume_translateCamera(self, v)

    def zVector(self):
        r"""zVector(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_zVector(self)

    def zNarrow(self, nearval, farval):
        r"""zNarrow(SbViewVolume self, float nearval, float farval) -> SbViewVolume"""
        return _coin.SbViewVolume_zNarrow(self, nearval, farval)

    def scale(self, factor):
        r"""scale(SbViewVolume self, float factor)"""
        return _coin.SbViewVolume_scale(self, factor)

    def scaleWidth(self, ratio):
        r"""scaleWidth(SbViewVolume self, float ratio)"""
        return _coin.SbViewVolume_scaleWidth(self, ratio)

    def scaleHeight(self, ratio):
        r"""scaleHeight(SbViewVolume self, float ratio)"""
        return _coin.SbViewVolume_scaleHeight(self, ratio)

    def getProjectionType(self):
        r"""getProjectionType(SbViewVolume self) -> SbViewVolume::ProjectionType"""
        return _coin.SbViewVolume_getProjectionType(self)

    def getProjectionPoint(self):
        r"""getProjectionPoint(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getProjectionPoint(self)

    def getProjectionDirection(self):
        r"""getProjectionDirection(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getProjectionDirection(self)

    def getNearDist(self):
        r"""getNearDist(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getNearDist(self)

    def getWidth(self):
        r"""getWidth(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getWidth(self)

    def getHeight(self):
        r"""getHeight(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getHeight(self)

    def getDepth(self):
        r"""getDepth(SbViewVolume self) -> float"""
        return _coin.SbViewVolume_getDepth(self)

    def output(self, fp):
        r"""output(SbViewVolume self, FILE * fp)"""
        return _coin.SbViewVolume_output(self, fp)

    def getViewVolumePlanes(self, planes):
        r"""getViewVolumePlanes(SbViewVolume self, SbPlane planes)"""
        return _coin.SbViewVolume_getViewVolumePlanes(self, planes)

    def transform(self):
        r"""transform(SbViewVolume self)"""
        return _coin.SbViewVolume_transform(self)

    def getViewUp(self):
        r"""getViewUp(SbViewVolume self) -> SbVec3f"""
        return _coin.SbViewVolume_getViewUp(self)

    def intersect(self, *args):
        r"""
        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):
        r"""outsideTest(SbViewVolume self, SbPlane p, SbVec3f bmin, SbVec3f bmax) -> SbBool"""
        return _coin.SbViewVolume_outsideTest(self, p, bmin, bmax)

    def getDPViewVolume(self):
        r"""getDPViewVolume(SbViewVolume self) -> SbDPViewVolume"""
        return _coin.SbViewVolume_getDPViewVolume(self)
    type = property(_coin.SbViewVolume_type_get, _coin.SbViewVolume_type_set, doc=r"""type : SbViewVolume::ProjectionType""")
    projPoint = property(_coin.SbViewVolume_projPoint_get, _coin.SbViewVolume_projPoint_set, doc=r"""projPoint : SbVec3f""")
    projDir = property(_coin.SbViewVolume_projDir_get, _coin.SbViewVolume_projDir_set, doc=r"""projDir : SbVec3f""")
    nearDist = property(_coin.SbViewVolume_nearDist_get, _coin.SbViewVolume_nearDist_set, doc=r"""nearDist : float""")
    nearToFar = property(_coin.SbViewVolume_nearToFar_get, _coin.SbViewVolume_nearToFar_set, doc=r"""nearToFar : float""")
    llf = property(_coin.SbViewVolume_llf_get, _coin.SbViewVolume_llf_set, doc=r"""llf : SbVec3f""")
    lrf = property(_coin.SbViewVolume_lrf_get, _coin.SbViewVolume_lrf_set, doc=r"""lrf : SbVec3f""")
    ulf = property(_coin.SbViewVolume_ulf_get, _coin.SbViewVolume_ulf_set, doc=r"""ulf : SbVec3f""")

    def projectPointToLine(self, pt):
        r"""projectPointToLine(SbVec3f) -> (SbVec3f, SbVec3f)"""
        return _coin.SbViewVolume_projectPointToLine(self, pt)

    def projectToScreen(self, src):
        r"""projectToScreen(SbVec3f) -> SbVec3f"""
        return _coin.SbViewVolume_projectToScreen(self, src)

# Register SbViewVolume in _coin:
_coin.SbViewVolume_swigregister(SbViewVolume)
class SoSFVec3f(SoSField):
    r"""Proxy of C++ SoSFVec3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec3f self) -> SoSFVec3f"""
        _coin.SoSFVec3f_swiginit(self, _coin.new_SoSFVec3f())
    __swig_destroy__ = _coin.delete_SoSFVec3f

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3f_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec3f self) -> SoType"""
        return _coin.SoSFVec3f_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec3f self, SoField field)"""
        return _coin.SoSFVec3f_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec3f self, SoField field) -> SbBool"""
        return _coin.SoSFVec3f_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec3f self) -> SbVec3f"""
        return _coin.SoSFVec3f_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec3f self, SoSFVec3f field) -> int"""
        return _coin.SoSFVec3f___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec3f self, SoSFVec3f field) -> int"""
        return _coin.SoSFVec3f___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec3f_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec3f in _coin:
_coin.SoSFVec3f_swigregister(SoSFVec3f)
class SoScale(SoTransformation):
    r"""Proxy of C++ SoScale class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScale_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoScale self) -> SoType"""
        return _coin.SoScale_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoScale_initClass()

    def __init__(self):
        r"""__init__(SoScale self) -> SoScale"""
        _coin.SoScale_swiginit(self, _coin.new_SoScale())
    scaleFactor = property(_coin.SoScale_scaleFactor_get, _coin.SoScale_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

    def doAction(self, action):
        r"""doAction(SoScale self, SoAction action)"""
        return _coin.SoScale_doAction(self, action)

    def callback(self, action):
        r"""callback(SoScale self, SoCallbackAction action)"""
        return _coin.SoScale_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoScale self, SoGLRenderAction action)"""
        return _coin.SoScale_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoScale self, SoGetBoundingBoxAction action)"""
        return _coin.SoScale_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoScale self, SoGetMatrixAction action)"""
        return _coin.SoScale_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoScale self, SoPickAction action)"""
        return _coin.SoScale_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoScale self, SoGetPrimitiveCountAction action)"""
        return _coin.SoScale_getPrimitiveCount(self, action)

# Register SoScale in _coin:
_coin.SoScale_swigregister(SoScale)
class SoDragger(SoInteractionKit):
    r"""Proxy of C++ SoDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDragger self) -> SoType"""
        return _coin.SoDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoDragger self) -> SoNodekitCatalog"""
        return _coin.SoDragger_getNodekitCatalog(self)
    isActive = property(_coin.SoDragger_isActive_get, _coin.SoDragger_isActive_set, doc=r"""isActive : SoSFBool""")
    FRONT = _coin.SoDragger_FRONT
    
    BACK = _coin.SoDragger_BACK
    
    USE_PICK = _coin.SoDragger_USE_PICK
    

    def callback(self, action):
        r"""callback(SoDragger self, SoCallbackAction action)"""
        return _coin.SoDragger_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoDragger self, SoGLRenderAction action)"""
        return _coin.SoDragger_GLRender(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoDragger self, SoGetMatrixAction action)"""
        return _coin.SoDragger_getMatrix(self, action)

    def rayPick(self, action):
        r"""rayPick(SoDragger self, SoRayPickAction action)"""
        return _coin.SoDragger_rayPick(self, action)

    def search(self, action):
        r"""search(SoDragger self, SoSearchAction action)"""
        return _coin.SoDragger_search(self, action)

    def write(self, action):
        r"""write(SoDragger self, SoWriteAction action)"""
        return _coin.SoDragger_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoDragger self, SoGetPrimitiveCountAction action)"""
        return _coin.SoDragger_getPrimitiveCount(self, action)

    def setProjectorEpsilon(self, epsilon):
        r"""setProjectorEpsilon(SoDragger self, float const epsilon)"""
        return _coin.SoDragger_setProjectorEpsilon(self, epsilon)

    def getProjectorEpsilon(self):
        r"""getProjectorEpsilon(SoDragger self) -> float"""
        return _coin.SoDragger_getProjectorEpsilon(self)

    def setMinGesture(self, pixels):
        r"""setMinGesture(SoDragger self, int pixels)"""
        return _coin.SoDragger_setMinGesture(self, pixels)

    def getMinGesture(self):
        r"""getMinGesture(SoDragger self) -> int"""
        return _coin.SoDragger_getMinGesture(self)

    def enableValueChangedCallbacks(self, newval):
        r"""enableValueChangedCallbacks(SoDragger self, SbBool newval) -> SbBool"""
        return _coin.SoDragger_enableValueChangedCallbacks(self, newval)

    def getMotionMatrix(self):
        r"""getMotionMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getMotionMatrix(self)

    def registerChildDragger(self, child):
        r"""registerChildDragger(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_registerChildDragger(self, child)

    def unregisterChildDragger(self, child):
        r"""unregisterChildDragger(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_unregisterChildDragger(self, child)

    def registerChildDraggerMovingIndependently(self, child):
        r"""registerChildDraggerMovingIndependently(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_registerChildDraggerMovingIndependently(self, child)

    def unregisterChildDraggerMovingIndependently(self, child):
        r"""unregisterChildDraggerMovingIndependently(SoDragger self, SoDragger child)"""
        return _coin.SoDragger_unregisterChildDraggerMovingIndependently(self, child)

    def getLocalToWorldMatrix(self):
        r"""getLocalToWorldMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getLocalToWorldMatrix(self)

    def getWorldToLocalMatrix(self):
        r"""getWorldToLocalMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getWorldToLocalMatrix(self)

    def getLocalStartingPoint(self):
        r"""getLocalStartingPoint(SoDragger self) -> SbVec3f"""
        return _coin.SoDragger_getLocalStartingPoint(self)

    def getWorldStartingPoint(self):
        r"""getWorldStartingPoint(SoDragger self) -> SbVec3f"""
        return _coin.SoDragger_getWorldStartingPoint(self)

    def getPartToLocalMatrix(self, partname, parttolocalmatrix, localtopartmatrix):
        r"""getPartToLocalMatrix(SoDragger self, SbName partname, SbMatrix parttolocalmatrix, SbMatrix localtopartmatrix)"""
        return _coin.SoDragger_getPartToLocalMatrix(self, partname, parttolocalmatrix, localtopartmatrix)

    def transformMatrixLocalToWorld(self, frommatrix, tomatrix):
        r"""transformMatrixLocalToWorld(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"""
        return _coin.SoDragger_transformMatrixLocalToWorld(self, frommatrix, tomatrix)

    def transformMatrixWorldToLocal(self, frommatrix, tomatrix):
        r"""transformMatrixWorldToLocal(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"""
        return _coin.SoDragger_transformMatrixWorldToLocal(self, frommatrix, tomatrix)

    def transformMatrixToLocalSpace(self, frommatrix, tomatrix, fromspacepartname):
        r"""transformMatrixToLocalSpace(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix, SbName fromspacepartname)"""
        return _coin.SoDragger_transformMatrixToLocalSpace(self, frommatrix, tomatrix, fromspacepartname)

    def setMotionMatrix(self, newmatrix):
        r"""setMotionMatrix(SoDragger self, SbMatrix newmatrix)"""
        return _coin.SoDragger_setMotionMatrix(self, newmatrix)

    def valueChanged(self):
        r"""valueChanged(SoDragger self)"""
        return _coin.SoDragger_valueChanged(self)

    def getStartMotionMatrix(self):
        r"""getStartMotionMatrix(SoDragger self) -> SbMatrix"""
        return _coin.SoDragger_getStartMotionMatrix(self)

    def saveStartParameters(self):
        r"""saveStartParameters(SoDragger self)"""
        return _coin.SoDragger_saveStartParameters(self)

    def getPickPath(self):
        r"""getPickPath(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getPickPath(self)

    def getEvent(self):
        r"""getEvent(SoDragger self) -> SoEvent"""
        return _coin.SoDragger_getEvent(self)

    def createPathToThis(self):
        r"""createPathToThis(SoDragger self) -> SoPath"""
        return _coin.SoDragger_createPathToThis(self)

    def getSurrogatePartPickedOwner(self):
        r"""getSurrogatePartPickedOwner(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getSurrogatePartPickedOwner(self)

    def getSurrogatePartPickedName(self):
        r"""getSurrogatePartPickedName(SoDragger self) -> SbName"""
        return _coin.SoDragger_getSurrogatePartPickedName(self)

    def getSurrogatePartPickedPath(self):
        r"""getSurrogatePartPickedPath(SoDragger self) -> SoPath"""
        return _coin.SoDragger_getSurrogatePartPickedPath(self)

    def setStartingPoint(self, *args):
        r"""
        setStartingPoint(SoDragger self, SoPickedPoint newpoint)
        setStartingPoint(SoDragger self, SbVec3f newpoint)
        """
        return _coin.SoDragger_setStartingPoint(self, *args)

    def getViewVolume(self):
        r"""getViewVolume(SoDragger self) -> SbViewVolume"""
        return _coin.SoDragger_getViewVolume(self)

    def setViewVolume(self, vol):
        r"""setViewVolume(SoDragger self, SbViewVolume vol)"""
        return _coin.SoDragger_setViewVolume(self, vol)

    def getViewportRegion(self):
        r"""getViewportRegion(SoDragger self) -> SbViewportRegion"""
        return _coin.SoDragger_getViewportRegion(self)

    def setViewportRegion(self, reg):
        r"""setViewportRegion(SoDragger self, SbViewportRegion reg)"""
        return _coin.SoDragger_setViewportRegion(self, reg)

    def getHandleEventAction(self):
        r"""getHandleEventAction(SoDragger self) -> SoHandleEventAction"""
        return _coin.SoDragger_getHandleEventAction(self)

    def setHandleEventAction(self, newAction):
        r"""setHandleEventAction(SoDragger self, SoHandleEventAction newAction)"""
        return _coin.SoDragger_setHandleEventAction(self, newAction)

    def setTempPathToThis(self, somethingclose):
        r"""setTempPathToThis(SoDragger self, SoPath somethingclose)"""
        return _coin.SoDragger_setTempPathToThis(self, somethingclose)

    def grabEventsSetup(self):
        r"""grabEventsSetup(SoDragger self)"""
        return _coin.SoDragger_grabEventsSetup(self)

    def grabEventsCleanup(self):
        r"""grabEventsCleanup(SoDragger self)"""
        return _coin.SoDragger_grabEventsCleanup(self)

    def workFieldsIntoTransform(self, mtx):
        r"""workFieldsIntoTransform(SoDragger self, SbMatrix mtx)"""
        return _coin.SoDragger_workFieldsIntoTransform(self, mtx)

    def setFrontOnProjector(self, newval):
        r"""setFrontOnProjector(SoDragger self, SoDragger::ProjectorFrontSetting newval)"""
        return _coin.SoDragger_setFrontOnProjector(self, newval)

    def getFrontOnProjector(self):
        r"""getFrontOnProjector(SoDragger self) -> SoDragger::ProjectorFrontSetting"""
        return _coin.SoDragger_getFrontOnProjector(self)

    @staticmethod
    def setMinScale(newminscale):
        r"""setMinScale(float newminscale)"""
        return _coin.SoDragger_setMinScale(newminscale)

    @staticmethod
    def getMinScale():
        r"""getMinScale() -> float"""
        return _coin.SoDragger_getMinScale()

    @staticmethod
    def workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr):
        r"""workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, SbVec3f scalefactorptr, SbRotation scaleorientationptr, SbVec3f centerptr)"""
        return _coin.SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr)

    @staticmethod
    def getTransformFast(*args):
        r"""
        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)

    @staticmethod
    def appendTranslation(mtx, translation, conversion=None):
        r"""appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion=None) -> SbMatrix"""
        return _coin.SoDragger_appendTranslation(mtx, translation, conversion)

    @staticmethod
    def appendScale(mtx, scale, scalecenter, conversion=None):
        r"""appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion=None) -> SbMatrix"""
        return _coin.SoDragger_appendScale(mtx, scale, scalecenter, conversion)

    @staticmethod
    def appendRotation(mtx, rot, rotcenter, conversion=None):
        r"""appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion=None) -> SbMatrix"""
        return _coin.SoDragger_appendRotation(mtx, rot, rotcenter, conversion)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDragger_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoDragger_initClasses()

    def addStartCallback(self, *args):
        r"""
        addStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addStartCallback(self, *args)

    def removeStartCallback(self, *args):
        r"""
        removeStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeStartCallback(self, *args)

    def addMotionCallback(self, *args):
        r"""
        addMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addMotionCallback(self, *args)

    def removeMotionCallback(self, *args):
        r"""
        removeMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeMotionCallback(self, *args)

    def addFinishCallback(self, *args):
        r"""
        addFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addFinishCallback(self, *args)

    def removeFinishCallback(self, *args):
        r"""
        removeFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeFinishCallback(self, *args)

    def addValueChangedCallback(self, *args):
        r"""
        addValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addValueChangedCallback(self, *args)

    def removeValueChangedCallback(self, *args):
        r"""
        removeValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeValueChangedCallback(self, *args)

    def addOtherEventCallback(self, *args):
        r"""
        addOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        addOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_addOtherEventCallback(self, *args)

    def removeOtherEventCallback(self, *args):
        r"""
        removeOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)
        removeOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
        """
        return _coin.SoDragger_removeOtherEventCallback(self, *args)

# Register SoDragger in _coin:
_coin.SoDragger_swigregister(SoDragger)
class SoSFRotation(SoSField):
    r"""Proxy of C++ SoSFRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFRotation self) -> SoSFRotation"""
        _coin.SoSFRotation_swiginit(self, _coin.new_SoSFRotation())
    __swig_destroy__ = _coin.delete_SoSFRotation

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFRotation_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFRotation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFRotation self) -> SoType"""
        return _coin.SoSFRotation_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFRotation self, SoField field)"""
        return _coin.SoSFRotation_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFRotation self, SoField field) -> SbBool"""
        return _coin.SoSFRotation_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFRotation self, SoSFRotation field) -> int"""
        return _coin.SoSFRotation___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFRotation self, SoSFRotation field) -> int"""
        return _coin.SoSFRotation___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFRotation_initClass()

    def getValue(self, *args):
        r"""
        getValue(SoSFRotation self) -> SbRotation
        getValue(SoSFRotation self, float & angle)
        """
        return _coin.SoSFRotation_getValue(self, *args)

    def setValue(self, *args):
        r"""
        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)

# Register SoSFRotation in _coin:
_coin.SoSFRotation_swigregister(SoSFRotation)
class SoCenterballDragger(SoDragger):
    r"""Proxy of C++ SoCenterballDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCenterballDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCenterballDragger self) -> SoType"""
        return _coin.SoCenterballDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoCenterballDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoCenterballDragger self) -> SoNodekitCatalog"""
        return _coin.SoCenterballDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCenterballDragger_initClass()

    def __init__(self):
        r"""__init__(SoCenterballDragger self) -> SoCenterballDragger"""
        _coin.SoCenterballDragger_swiginit(self, _coin.new_SoCenterballDragger())

    def saveStartParameters(self):
        r"""saveStartParameters(SoCenterballDragger self)"""
        return _coin.SoCenterballDragger_saveStartParameters(self)
    rotation = property(_coin.SoCenterballDragger_rotation_get, _coin.SoCenterballDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    center = property(_coin.SoCenterballDragger_center_get, _coin.SoCenterballDragger_center_set, doc=r"""center : SoSFVec3f""")

# Register SoCenterballDragger in _coin:
_coin.SoCenterballDragger_swigregister(SoCenterballDragger)
class SoDirectionalLightDragger(SoDragger):
    r"""Proxy of C++ SoDirectionalLightDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLightDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDirectionalLightDragger self) -> SoType"""
        return _coin.SoDirectionalLightDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDirectionalLightDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoDirectionalLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoDirectionalLightDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDirectionalLightDragger_initClass()

    def __init__(self):
        r"""__init__(SoDirectionalLightDragger self) -> SoDirectionalLightDragger"""
        _coin.SoDirectionalLightDragger_swiginit(self, _coin.new_SoDirectionalLightDragger())
    rotation = property(_coin.SoDirectionalLightDragger_rotation_get, _coin.SoDirectionalLightDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoDirectionalLightDragger_translation_get, _coin.SoDirectionalLightDragger_translation_set, doc=r"""translation : SoSFVec3f""")

# Register SoDirectionalLightDragger in _coin:
_coin.SoDirectionalLightDragger_swigregister(SoDirectionalLightDragger)
class SoDragPointDragger(SoDragger):
    r"""Proxy of C++ SoDragPointDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDragPointDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDragPointDragger self) -> SoType"""
        return _coin.SoDragPointDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoDragPointDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoDragPointDragger self) -> SoNodekitCatalog"""
        return _coin.SoDragPointDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDragPointDragger_initClass()

    def __init__(self):
        r"""__init__(SoDragPointDragger self) -> SoDragPointDragger"""
        _coin.SoDragPointDragger_swiginit(self, _coin.new_SoDragPointDragger())
    translation = property(_coin.SoDragPointDragger_translation_get, _coin.SoDragPointDragger_translation_set, doc=r"""translation : SoSFVec3f""")

    def setJumpLimit(self, limit):
        r"""setJumpLimit(SoDragPointDragger self, float const limit)"""
        return _coin.SoDragPointDragger_setJumpLimit(self, limit)

    def getJumpLimit(self):
        r"""getJumpLimit(SoDragPointDragger self) -> float"""
        return _coin.SoDragPointDragger_getJumpLimit(self)

    def showNextDraggerSet(self):
        r"""showNextDraggerSet(SoDragPointDragger self)"""
        return _coin.SoDragPointDragger_showNextDraggerSet(self)

# Register SoDragPointDragger in _coin:
_coin.SoDragPointDragger_swigregister(SoDragPointDragger)
class SoHandleBoxDragger(SoDragger):
    r"""Proxy of C++ SoHandleBoxDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoHandleBoxDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoHandleBoxDragger self) -> SoType"""
        return _coin.SoHandleBoxDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoHandleBoxDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoHandleBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoHandleBoxDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoHandleBoxDragger_initClass()

    def __init__(self):
        r"""__init__(SoHandleBoxDragger self) -> SoHandleBoxDragger"""
        _coin.SoHandleBoxDragger_swiginit(self, _coin.new_SoHandleBoxDragger())
    scaleFactor = property(_coin.SoHandleBoxDragger_scaleFactor_get, _coin.SoHandleBoxDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")
    translation = property(_coin.SoHandleBoxDragger_translation_get, _coin.SoHandleBoxDragger_translation_set, doc=r"""translation : SoSFVec3f""")

# Register SoHandleBoxDragger in _coin:
_coin.SoHandleBoxDragger_swigregister(SoHandleBoxDragger)
class SoJackDragger(SoDragger):
    r"""Proxy of C++ SoJackDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoJackDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoJackDragger self) -> SoType"""
        return _coin.SoJackDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoJackDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoJackDragger self) -> SoNodekitCatalog"""
        return _coin.SoJackDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoJackDragger_initClass()

    def __init__(self):
        r"""__init__(SoJackDragger self) -> SoJackDragger"""
        _coin.SoJackDragger_swiginit(self, _coin.new_SoJackDragger())
    rotation = property(_coin.SoJackDragger_rotation_get, _coin.SoJackDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoJackDragger_translation_get, _coin.SoJackDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoJackDragger_scaleFactor_get, _coin.SoJackDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoJackDragger in _coin:
_coin.SoJackDragger_swigregister(SoJackDragger)
class SoPointLightDragger(SoDragger):
    r"""Proxy of C++ SoPointLightDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointLightDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPointLightDragger self) -> SoType"""
        return _coin.SoPointLightDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoPointLightDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoPointLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoPointLightDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPointLightDragger_initClass()

    def __init__(self):
        r"""__init__(SoPointLightDragger self) -> SoPointLightDragger"""
        _coin.SoPointLightDragger_swiginit(self, _coin.new_SoPointLightDragger())
    translation = property(_coin.SoPointLightDragger_translation_get, _coin.SoPointLightDragger_translation_set, doc=r"""translation : SoSFVec3f""")

# Register SoPointLightDragger in _coin:
_coin.SoPointLightDragger_swigregister(SoPointLightDragger)
class SoRotateCylindricalDragger(SoDragger):
    r"""Proxy of C++ SoRotateCylindricalDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotateCylindricalDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoRotateCylindricalDragger self) -> SoType"""
        return _coin.SoRotateCylindricalDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateCylindricalDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoRotateCylindricalDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateCylindricalDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoRotateCylindricalDragger_initClass()

    def __init__(self):
        r"""__init__(SoRotateCylindricalDragger self) -> SoRotateCylindricalDragger"""
        _coin.SoRotateCylindricalDragger_swiginit(self, _coin.new_SoRotateCylindricalDragger())
    rotation = property(_coin.SoRotateCylindricalDragger_rotation_get, _coin.SoRotateCylindricalDragger_rotation_set, doc=r"""rotation : SoSFRotation""")

    def setProjector(self, p):
        r"""setProjector(SoRotateCylindricalDragger self, SbCylinderProjector p)"""
        return _coin.SoRotateCylindricalDragger_setProjector(self, p)

    def getProjector(self):
        r"""getProjector(SoRotateCylindricalDragger self) -> SbCylinderProjector"""
        return _coin.SoRotateCylindricalDragger_getProjector(self)

# Register SoRotateCylindricalDragger in _coin:
_coin.SoRotateCylindricalDragger_swigregister(SoRotateCylindricalDragger)
class SoRotateDiscDragger(SoDragger):
    r"""Proxy of C++ SoRotateDiscDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotateDiscDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoRotateDiscDragger self) -> SoType"""
        return _coin.SoRotateDiscDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateDiscDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoRotateDiscDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateDiscDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoRotateDiscDragger_initClass()

    def __init__(self):
        r"""__init__(SoRotateDiscDragger self) -> SoRotateDiscDragger"""
        _coin.SoRotateDiscDragger_swiginit(self, _coin.new_SoRotateDiscDragger())
    rotation = property(_coin.SoRotateDiscDragger_rotation_get, _coin.SoRotateDiscDragger_rotation_set, doc=r"""rotation : SoSFRotation""")

# Register SoRotateDiscDragger in _coin:
_coin.SoRotateDiscDragger_swigregister(SoRotateDiscDragger)
class SoRotateSphericalDragger(SoDragger):
    r"""Proxy of C++ SoRotateSphericalDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotateSphericalDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoRotateSphericalDragger self) -> SoType"""
        return _coin.SoRotateSphericalDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoRotateSphericalDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoRotateSphericalDragger self) -> SoNodekitCatalog"""
        return _coin.SoRotateSphericalDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoRotateSphericalDragger_initClass()

    def __init__(self):
        r"""__init__(SoRotateSphericalDragger self) -> SoRotateSphericalDragger"""
        _coin.SoRotateSphericalDragger_swiginit(self, _coin.new_SoRotateSphericalDragger())
    rotation = property(_coin.SoRotateSphericalDragger_rotation_get, _coin.SoRotateSphericalDragger_rotation_set, doc=r"""rotation : SoSFRotation""")

    def setProjector(self, p):
        r"""setProjector(SoRotateSphericalDragger self, SbSphereProjector p)"""
        return _coin.SoRotateSphericalDragger_setProjector(self, p)

    def getProjector(self):
        r"""getProjector(SoRotateSphericalDragger self) -> SbSphereProjector"""
        return _coin.SoRotateSphericalDragger_getProjector(self)

# Register SoRotateSphericalDragger in _coin:
_coin.SoRotateSphericalDragger_swigregister(SoRotateSphericalDragger)
class SoScale1Dragger(SoDragger):
    r"""Proxy of C++ SoScale1Dragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScale1Dragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoScale1Dragger self) -> SoType"""
        return _coin.SoScale1Dragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale1Dragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoScale1Dragger self) -> SoNodekitCatalog"""
        return _coin.SoScale1Dragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoScale1Dragger_initClass()

    def __init__(self):
        r"""__init__(SoScale1Dragger self) -> SoScale1Dragger"""
        _coin.SoScale1Dragger_swiginit(self, _coin.new_SoScale1Dragger())
    scaleFactor = property(_coin.SoScale1Dragger_scaleFactor_get, _coin.SoScale1Dragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoScale1Dragger in _coin:
_coin.SoScale1Dragger_swigregister(SoScale1Dragger)
class SoScale2Dragger(SoDragger):
    r"""Proxy of C++ SoScale2Dragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScale2Dragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoScale2Dragger self) -> SoType"""
        return _coin.SoScale2Dragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale2Dragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoScale2Dragger self) -> SoNodekitCatalog"""
        return _coin.SoScale2Dragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoScale2Dragger_initClass()

    def __init__(self):
        r"""__init__(SoScale2Dragger self) -> SoScale2Dragger"""
        _coin.SoScale2Dragger_swiginit(self, _coin.new_SoScale2Dragger())
    scaleFactor = property(_coin.SoScale2Dragger_scaleFactor_get, _coin.SoScale2Dragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoScale2Dragger in _coin:
_coin.SoScale2Dragger_swigregister(SoScale2Dragger)
class SoScale2UniformDragger(SoDragger):
    r"""Proxy of C++ SoScale2UniformDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScale2UniformDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoScale2UniformDragger self) -> SoType"""
        return _coin.SoScale2UniformDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScale2UniformDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoScale2UniformDragger self) -> SoNodekitCatalog"""
        return _coin.SoScale2UniformDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoScale2UniformDragger_initClass()

    def __init__(self):
        r"""__init__(SoScale2UniformDragger self) -> SoScale2UniformDragger"""
        _coin.SoScale2UniformDragger_swiginit(self, _coin.new_SoScale2UniformDragger())
    scaleFactor = property(_coin.SoScale2UniformDragger_scaleFactor_get, _coin.SoScale2UniformDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoScale2UniformDragger in _coin:
_coin.SoScale2UniformDragger_swigregister(SoScale2UniformDragger)
class SoScaleUniformDragger(SoDragger):
    r"""Proxy of C++ SoScaleUniformDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScaleUniformDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoScaleUniformDragger self) -> SoType"""
        return _coin.SoScaleUniformDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoScaleUniformDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoScaleUniformDragger self) -> SoNodekitCatalog"""
        return _coin.SoScaleUniformDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoScaleUniformDragger_initClass()

    def __init__(self):
        r"""__init__(SoScaleUniformDragger self) -> SoScaleUniformDragger"""
        _coin.SoScaleUniformDragger_swiginit(self, _coin.new_SoScaleUniformDragger())
    scaleFactor = property(_coin.SoScaleUniformDragger_scaleFactor_get, _coin.SoScaleUniformDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoScaleUniformDragger in _coin:
_coin.SoScaleUniformDragger_swigregister(SoScaleUniformDragger)
class SoSpotLightDragger(SoDragger):
    r"""Proxy of C++ SoSpotLightDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpotLightDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSpotLightDragger self) -> SoType"""
        return _coin.SoSpotLightDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSpotLightDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoSpotLightDragger self) -> SoNodekitCatalog"""
        return _coin.SoSpotLightDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSpotLightDragger_initClass()

    def __init__(self):
        r"""__init__(SoSpotLightDragger self) -> SoSpotLightDragger"""
        _coin.SoSpotLightDragger_swiginit(self, _coin.new_SoSpotLightDragger())
    rotation = property(_coin.SoSpotLightDragger_rotation_get, _coin.SoSpotLightDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoSpotLightDragger_translation_get, _coin.SoSpotLightDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    angle = property(_coin.SoSpotLightDragger_angle_get, _coin.SoSpotLightDragger_angle_set, doc=r"""angle : SoSFFloat""")

# Register SoSpotLightDragger in _coin:
_coin.SoSpotLightDragger_swigregister(SoSpotLightDragger)
class SoTabBoxDragger(SoDragger):
    r"""Proxy of C++ SoTabBoxDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTabBoxDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTabBoxDragger self) -> SoType"""
        return _coin.SoTabBoxDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTabBoxDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoTabBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoTabBoxDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTabBoxDragger_initClass()

    def __init__(self):
        r"""__init__(SoTabBoxDragger self) -> SoTabBoxDragger"""
        _coin.SoTabBoxDragger_swiginit(self, _coin.new_SoTabBoxDragger())
    translation = property(_coin.SoTabBoxDragger_translation_get, _coin.SoTabBoxDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoTabBoxDragger_scaleFactor_get, _coin.SoTabBoxDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

    def adjustScaleTabSize(self):
        r"""adjustScaleTabSize(SoTabBoxDragger self)"""
        return _coin.SoTabBoxDragger_adjustScaleTabSize(self)

# Register SoTabBoxDragger in _coin:
_coin.SoTabBoxDragger_swigregister(SoTabBoxDragger)
class SoTabPlaneDragger(SoDragger):
    r"""Proxy of C++ SoTabPlaneDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTabPlaneDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTabPlaneDragger self) -> SoType"""
        return _coin.SoTabPlaneDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTabPlaneDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoTabPlaneDragger self) -> SoNodekitCatalog"""
        return _coin.SoTabPlaneDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTabPlaneDragger_initClass()

    def __init__(self):
        r"""__init__(SoTabPlaneDragger self) -> SoTabPlaneDragger"""
        _coin.SoTabPlaneDragger_swiginit(self, _coin.new_SoTabPlaneDragger())
    translation = property(_coin.SoTabPlaneDragger_translation_get, _coin.SoTabPlaneDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoTabPlaneDragger_scaleFactor_get, _coin.SoTabPlaneDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

    def adjustScaleTabSize(self):
        r"""adjustScaleTabSize(SoTabPlaneDragger self)"""
        return _coin.SoTabPlaneDragger_adjustScaleTabSize(self)

# Register SoTabPlaneDragger in _coin:
_coin.SoTabPlaneDragger_swigregister(SoTabPlaneDragger)
class SoTrackballDragger(SoDragger):
    r"""Proxy of C++ SoTrackballDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTrackballDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTrackballDragger self) -> SoType"""
        return _coin.SoTrackballDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTrackballDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoTrackballDragger self) -> SoNodekitCatalog"""
        return _coin.SoTrackballDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTrackballDragger_initClass()

    def __init__(self):
        r"""__init__(SoTrackballDragger self) -> SoTrackballDragger"""
        _coin.SoTrackballDragger_swiginit(self, _coin.new_SoTrackballDragger())
    rotation = property(_coin.SoTrackballDragger_rotation_get, _coin.SoTrackballDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    scaleFactor = property(_coin.SoTrackballDragger_scaleFactor_get, _coin.SoTrackballDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

    def isAnimationEnabled(self):
        r"""isAnimationEnabled(SoTrackballDragger self) -> SbBool"""
        return _coin.SoTrackballDragger_isAnimationEnabled(self)

    def setAnimationEnabled(self, newval):
        r"""setAnimationEnabled(SoTrackballDragger self, SbBool newval)"""
        return _coin.SoTrackballDragger_setAnimationEnabled(self, newval)

# Register SoTrackballDragger in _coin:
_coin.SoTrackballDragger_swigregister(SoTrackballDragger)
class SoTransformBoxDragger(SoDragger):
    r"""Proxy of C++ SoTransformBoxDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformBoxDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransformBoxDragger self) -> SoType"""
        return _coin.SoTransformBoxDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTransformBoxDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoTransformBoxDragger self) -> SoNodekitCatalog"""
        return _coin.SoTransformBoxDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransformBoxDragger_initClass()

    def __init__(self):
        r"""__init__(SoTransformBoxDragger self) -> SoTransformBoxDragger"""
        _coin.SoTransformBoxDragger_swiginit(self, _coin.new_SoTransformBoxDragger())
    rotation = property(_coin.SoTransformBoxDragger_rotation_get, _coin.SoTransformBoxDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoTransformBoxDragger_translation_get, _coin.SoTransformBoxDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoTransformBoxDragger_scaleFactor_get, _coin.SoTransformBoxDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")

# Register SoTransformBoxDragger in _coin:
_coin.SoTransformBoxDragger_swigregister(SoTransformBoxDragger)
class SoTransformerDragger(SoDragger):
    r"""Proxy of C++ SoTransformerDragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformerDragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransformerDragger self) -> SoType"""
        return _coin.SoTransformerDragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTransformerDragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoTransformerDragger self) -> SoNodekitCatalog"""
        return _coin.SoTransformerDragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransformerDragger_initClass()

    def __init__(self):
        r"""__init__(SoTransformerDragger self) -> SoTransformerDragger"""
        _coin.SoTransformerDragger_swiginit(self, _coin.new_SoTransformerDragger())
    rotation = property(_coin.SoTransformerDragger_rotation_get, _coin.SoTransformerDragger_rotation_set, doc=r"""rotation : SoSFRotation""")
    translation = property(_coin.SoTransformerDragger_translation_get, _coin.SoTransformerDragger_translation_set, doc=r"""translation : SoSFVec3f""")
    scaleFactor = property(_coin.SoTransformerDragger_scaleFactor_get, _coin.SoTransformerDragger_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")
    minDiscRotDot = property(_coin.SoTransformerDragger_minDiscRotDot_get, _coin.SoTransformerDragger_minDiscRotDot_set, doc=r"""minDiscRotDot : SoSFFloat""")
    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):
        r"""getCurrentState(SoTransformerDragger self) -> SoTransformerDragger::State"""
        return _coin.SoTransformerDragger_getCurrentState(self)

    def unsquishKnobs(self):
        r"""unsquishKnobs(SoTransformerDragger self)"""
        return _coin.SoTransformerDragger_unsquishKnobs(self)

    def isLocateHighlighting(self):
        r"""isLocateHighlighting(SoTransformerDragger self) -> SbBool"""
        return _coin.SoTransformerDragger_isLocateHighlighting(self)

    def setLocateHighlighting(self, onoff):
        r"""setLocateHighlighting(SoTransformerDragger self, SbBool onoff)"""
        return _coin.SoTransformerDragger_setLocateHighlighting(self, onoff)

    @staticmethod
    def setColinearThreshold(newval):
        r"""setColinearThreshold(int newval)"""
        return _coin.SoTransformerDragger_setColinearThreshold(newval)

    @staticmethod
    def getColinearThreshold():
        r"""getColinearThreshold() -> int"""
        return _coin.SoTransformerDragger_getColinearThreshold()

    def getBoxPointInWorldSpace(self, pointonunitbox):
        r"""getBoxPointInWorldSpace(SoTransformerDragger self, SbVec3f pointonunitbox) -> SbVec3f"""
        return _coin.SoTransformerDragger_getBoxPointInWorldSpace(self, pointonunitbox)

    def getBoxDirInWorldSpace(self, dironunitbox):
        r"""getBoxDirInWorldSpace(SoTransformerDragger self, SbVec3f dironunitbox) -> SbVec3f"""
        return _coin.SoTransformerDragger_getBoxDirInWorldSpace(self, dironunitbox)

    def getWorldPointInBoxSpace(self, pointinworldspace):
        r"""getWorldPointInBoxSpace(SoTransformerDragger self, SbVec3f pointinworldspace) -> SbVec3f"""
        return _coin.SoTransformerDragger_getWorldPointInBoxSpace(self, pointinworldspace)

    def getWorldPointInPixelSpace(self, thepoint):
        r"""getWorldPointInPixelSpace(SoTransformerDragger self, SbVec3f thepoint) -> SbVec2f"""
        return _coin.SoTransformerDragger_getWorldPointInPixelSpace(self, thepoint)

    def getInteractiveCenterInBoxSpace(self):
        r"""getInteractiveCenterInBoxSpace(SoTransformerDragger self) -> SbVec3f"""
        return _coin.SoTransformerDragger_getInteractiveCenterInBoxSpace(self)

# Register SoTransformerDragger in _coin:
_coin.SoTransformerDragger_swigregister(SoTransformerDragger)
class SoTranslate1Dragger(SoDragger):
    r"""Proxy of C++ SoTranslate1Dragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTranslate1Dragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTranslate1Dragger self) -> SoType"""
        return _coin.SoTranslate1Dragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTranslate1Dragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoTranslate1Dragger self) -> SoNodekitCatalog"""
        return _coin.SoTranslate1Dragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTranslate1Dragger_initClass()

    def __init__(self):
        r"""__init__(SoTranslate1Dragger self) -> SoTranslate1Dragger"""
        _coin.SoTranslate1Dragger_swiginit(self, _coin.new_SoTranslate1Dragger())
    translation = property(_coin.SoTranslate1Dragger_translation_get, _coin.SoTranslate1Dragger_translation_set, doc=r"""translation : SoSFVec3f""")
    minTranslation = property(_coin.SoTranslate1Dragger_minTranslation_get, _coin.SoTranslate1Dragger_minTranslation_set, doc=r"""minTranslation : SoSFFloat""")
    maxTranslation = property(_coin.SoTranslate1Dragger_maxTranslation_get, _coin.SoTranslate1Dragger_maxTranslation_set, doc=r"""maxTranslation : SoSFFloat""")

# Register SoTranslate1Dragger in _coin:
_coin.SoTranslate1Dragger_swigregister(SoTranslate1Dragger)
class SoSFVec2f(SoSField):
    r"""Proxy of C++ SoSFVec2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec2f self) -> SoSFVec2f"""
        _coin.SoSFVec2f_swiginit(self, _coin.new_SoSFVec2f())
    __swig_destroy__ = _coin.delete_SoSFVec2f

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2f_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec2f self) -> SoType"""
        return _coin.SoSFVec2f_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec2f self, SoField field)"""
        return _coin.SoSFVec2f_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec2f self, SoField field) -> SbBool"""
        return _coin.SoSFVec2f_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec2f self) -> SbVec2f"""
        return _coin.SoSFVec2f_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec2f self, SoSFVec2f field) -> int"""
        return _coin.SoSFVec2f___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec2f self, SoSFVec2f field) -> int"""
        return _coin.SoSFVec2f___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec2f_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec2f in _coin:
_coin.SoSFVec2f_swigregister(SoSFVec2f)
class SoTranslate2Dragger(SoDragger):
    r"""Proxy of C++ SoTranslate2Dragger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTranslate2Dragger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTranslate2Dragger self) -> SoType"""
        return _coin.SoTranslate2Dragger_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoTranslate2Dragger_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoTranslate2Dragger self) -> SoNodekitCatalog"""
        return _coin.SoTranslate2Dragger_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTranslate2Dragger_initClass()

    def __init__(self):
        r"""__init__(SoTranslate2Dragger self) -> SoTranslate2Dragger"""
        _coin.SoTranslate2Dragger_swiginit(self, _coin.new_SoTranslate2Dragger())
    translation = property(_coin.SoTranslate2Dragger_translation_get, _coin.SoTranslate2Dragger_translation_set, doc=r"""translation : SoSFVec3f""")
    minTranslation = property(_coin.SoTranslate2Dragger_minTranslation_get, _coin.SoTranslate2Dragger_minTranslation_set, doc=r"""minTranslation : SoSFVec2f""")
    maxTranslation = property(_coin.SoTranslate2Dragger_maxTranslation_get, _coin.SoTranslate2Dragger_maxTranslation_set, doc=r"""maxTranslation : SoSFVec2f""")

# Register SoTranslate2Dragger in _coin:
_coin.SoTranslate2Dragger_swigregister(SoTranslate2Dragger)
class SoAccumulatedElement(SoElement):
    r"""Proxy of C++ SoAccumulatedElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAccumulatedElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoAccumulatedElement_getClassStackIndex()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAccumulatedElement_initClass()

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

# Register SoAccumulatedElement in _coin:
_coin.SoAccumulatedElement_swigregister(SoAccumulatedElement)
class SoAmbientColorElement(SoReplacedElement):
    r"""Proxy of C++ SoAmbientColorElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAmbientColorElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoAmbientColorElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoAmbientColorElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAmbientColorElement_initClass()

    def init(self, state):
        r"""init(SoAmbientColorElement self, SoState state)"""
        return _coin.SoAmbientColorElement_init(self, state)

    @staticmethod
    def set(state, node, numcolors, colors):
        r"""set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoAmbientColorElement_set(state, node, numcolors, colors)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoAmbientColorElement"""
        return _coin.SoAmbientColorElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoAmbientColorElement self) -> int32_t"""
        return _coin.SoAmbientColorElement_getNum(self)

    def get(self, index):
        r"""get(SoAmbientColorElement self, int const index) -> SbColor"""
        return _coin.SoAmbientColorElement_get(self, index)

    def getArrayPtr(self):
        r"""getArrayPtr(SoAmbientColorElement self) -> SbColor"""
        return _coin.SoAmbientColorElement_getArrayPtr(self)

# Register SoAmbientColorElement in _coin:
_coin.SoAmbientColorElement_swigregister(SoAmbientColorElement)
class SoAnnoText3CharOrientElement(SoInt32Element):
    r"""Proxy of C++ SoAnnoText3CharOrientElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3CharOrientElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoAnnoText3CharOrientElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoAnnoText3CharOrientElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAnnoText3CharOrientElement_initClass()

    def init(self, state):
        r"""init(SoAnnoText3CharOrientElement self, SoState state)"""
        return _coin.SoAnnoText3CharOrientElement_init(self, state)

    @staticmethod
    def set(state, isOriented):
        r"""set(SoState state, SbBool isOriented)"""
        return _coin.SoAnnoText3CharOrientElement_set(state, isOriented)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbBool"""
        return _coin.SoAnnoText3CharOrientElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SbBool"""
        return _coin.SoAnnoText3CharOrientElement_getDefault()

# Register SoAnnoText3CharOrientElement in _coin:
_coin.SoAnnoText3CharOrientElement_swigregister(SoAnnoText3CharOrientElement)
class SoAnnoText3FontSizeHintElement(SoInt32Element):
    r"""Proxy of C++ SoAnnoText3FontSizeHintElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3FontSizeHintElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoAnnoText3FontSizeHintElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoAnnoText3FontSizeHintElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAnnoText3FontSizeHintElement_initClass()
    ANNOTATION = _coin.SoAnnoText3FontSizeHintElement_ANNOTATION
    
    FIT_TEXT_VECTOR = _coin.SoAnnoText3FontSizeHintElement_FIT_TEXT_VECTOR
    

    def init(self, state):
        r"""init(SoAnnoText3FontSizeHintElement self, SoState state)"""
        return _coin.SoAnnoText3FontSizeHintElement_init(self, state)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
        return _coin.SoAnnoText3FontSizeHintElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
        return _coin.SoAnnoText3FontSizeHintElement_getDefault()

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
        set(SoState state, SoNode node, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
        """
        return _coin.SoAnnoText3FontSizeHintElement_set(*args)

# Register SoAnnoText3FontSizeHintElement in _coin:
_coin.SoAnnoText3FontSizeHintElement_swigregister(SoAnnoText3FontSizeHintElement)
class SoAnnoText3RenderPrintElement(SoInt32Element):
    r"""Proxy of C++ SoAnnoText3RenderPrintElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAnnoText3RenderPrintElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoAnnoText3RenderPrintElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoAnnoText3RenderPrintElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAnnoText3RenderPrintElement_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):
        r"""init(SoAnnoText3RenderPrintElement self, SoState state)"""
        return _coin.SoAnnoText3RenderPrintElement_init(self, state)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoAnnoText3RenderPrintElement::RenderPrintType"""
        return _coin.SoAnnoText3RenderPrintElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoAnnoText3RenderPrintElement::RenderPrintType"""
        return _coin.SoAnnoText3RenderPrintElement_getDefault()

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoAnnoText3RenderPrintElement::RenderPrintType const hint)
        set(SoState state, SoNode node, SoAnnoText3RenderPrintElement::RenderPrintType const type)
        """
        return _coin.SoAnnoText3RenderPrintElement_set(*args)

# Register SoAnnoText3RenderPrintElement in _coin:
_coin.SoAnnoText3RenderPrintElement_swigregister(SoAnnoText3RenderPrintElement)
class SoModelMatrixElement(SoAccumulatedElement):
    r"""Proxy of C++ SoModelMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoModelMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoModelMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoModelMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoModelMatrixElement_initClass()

    def init(self, state):
        r"""init(SoModelMatrixElement self, SoState state)"""
        return _coin.SoModelMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoModelMatrixElement self, SoState state)"""
        return _coin.SoModelMatrixElement_push(self, state)

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

    @staticmethod
    def makeIdentity(state, node):
        r"""makeIdentity(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_makeIdentity(state, node)

    @staticmethod
    def set(state, node):
        r"""set(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_set(state, node)

    @staticmethod
    def setCullMatrix(state, node):
        r"""setCullMatrix(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_setCullMatrix(state, node)

    @staticmethod
    def mult(state, node):
        r"""mult(SoState state, SoNode node)"""
        return _coin.SoModelMatrixElement_mult(state, node)

    @staticmethod
    def translateBy(state, node, translation):
        r"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoModelMatrixElement_translateBy(state, node, translation)

    @staticmethod
    def rotateBy(state, node, rotation):
        r"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoModelMatrixElement_rotateBy(state, node, rotation)

    @staticmethod
    def scaleBy(state, node, scaleFactor):
        r"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoModelMatrixElement_scaleBy(state, node, scaleFactor)

    @staticmethod
    def pushMatrix(state):
        r"""pushMatrix(SoState state) -> SbMatrix"""
        return _coin.SoModelMatrixElement_pushMatrix(state)

    @staticmethod
    def popMatrix(state):
        r"""popMatrix(SoState state)"""
        return _coin.SoModelMatrixElement_popMatrix(state)

    @staticmethod
    def getCombinedCullMatrix(state):
        r"""getCombinedCullMatrix(SoState state) -> SbMatrix"""
        return _coin.SoModelMatrixElement_getCombinedCullMatrix(state)

    @staticmethod
    def get(*args):
        r"""
        get(SoState state) -> SbMatrix
        get(SoState state, SbBool & isIdentity) -> SbMatrix
        """
        return _coin.SoModelMatrixElement_get(*args)

    def getModelMatrix(self):
        r"""getModelMatrix(SoModelMatrixElement self) -> SbMatrix"""
        return _coin.SoModelMatrixElement_getModelMatrix(self)

# Register SoModelMatrixElement in _coin:
_coin.SoModelMatrixElement_swigregister(SoModelMatrixElement)
class SoBBoxModelMatrixElement(SoModelMatrixElement):
    r"""Proxy of C++ SoBBoxModelMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBBoxModelMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoBBoxModelMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoBBoxModelMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBBoxModelMatrixElement_initClass()

    def init(self, state):
        r"""init(SoBBoxModelMatrixElement self, SoState state)"""
        return _coin.SoBBoxModelMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoBBoxModelMatrixElement self, SoState state)"""
        return _coin.SoBBoxModelMatrixElement_push(self, state)

    @staticmethod
    def reset(state, node):
        r"""reset(SoState state, SoNode node)"""
        return _coin.SoBBoxModelMatrixElement_reset(state, node)

    @staticmethod
    def pushMatrix(state, localmatrix):
        r"""pushMatrix(SoState state, SbMatrix localmatrix)"""
        return _coin.SoBBoxModelMatrixElement_pushMatrix(state, localmatrix)

    @staticmethod
    def popMatrix(state, localmatrix):
        r"""popMatrix(SoState state, SbMatrix localmatrix)"""
        return _coin.SoBBoxModelMatrixElement_popMatrix(state, localmatrix)

# Register SoBBoxModelMatrixElement in _coin:
_coin.SoBBoxModelMatrixElement_swigregister(SoBBoxModelMatrixElement)
class SoBumpMapCoordinateElement(SoReplacedElement):
    r"""Proxy of C++ SoBumpMapCoordinateElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoBumpMapCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoBumpMapCoordinateElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBumpMapCoordinateElement_initClass()

    def init(self, state):
        r"""init(SoBumpMapCoordinateElement self, SoState state)"""
        return _coin.SoBumpMapCoordinateElement_init(self, state)

    @staticmethod
    def set(state, node, numcoords, coords):
        r"""set(SoState state, SoNode node, int32_t const numcoords, SbVec2f coords)"""
        return _coin.SoBumpMapCoordinateElement_set(state, node, numcoords, coords)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoBumpMapCoordinateElement"""
        return _coin.SoBumpMapCoordinateElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoBumpMapCoordinateElement self) -> int32_t"""
        return _coin.SoBumpMapCoordinateElement_getNum(self)

    def get(self, index):
        r"""get(SoBumpMapCoordinateElement self, int const index) -> SbVec2f"""
        return _coin.SoBumpMapCoordinateElement_get(self, index)

    def getArrayPtr(self):
        r"""getArrayPtr(SoBumpMapCoordinateElement self) -> SbVec2f"""
        return _coin.SoBumpMapCoordinateElement_getArrayPtr(self)

# Register SoBumpMapCoordinateElement in _coin:
_coin.SoBumpMapCoordinateElement_swigregister(SoBumpMapCoordinateElement)
class SoBumpMapElement(SoReplacedElement):
    r"""Proxy of C++ SoBumpMapElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoBumpMapElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoBumpMapElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBumpMapElement_initClass()

    def init(self, state):
        r"""init(SoBumpMapElement self, SoState state)"""
        return _coin.SoBumpMapElement_init(self, state)

    @staticmethod
    def set(state, node, image):
        r"""set(SoState state, SoNode node, SoGLImage image)"""
        return _coin.SoBumpMapElement_set(state, node, image)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoGLImage"""
        return _coin.SoBumpMapElement_get(state)

# Register SoBumpMapElement in _coin:
_coin.SoBumpMapElement_swigregister(SoBumpMapElement)
class SoBumpMapMatrixElement(SoAccumulatedElement):
    r"""Proxy of C++ SoBumpMapMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoBumpMapMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoBumpMapMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBumpMapMatrixElement_initClass()

    def init(self, state):
        r"""init(SoBumpMapMatrixElement self, SoState state)"""
        return _coin.SoBumpMapMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoBumpMapMatrixElement self, SoState state)"""
        return _coin.SoBumpMapMatrixElement_push(self, state)

    @staticmethod
    def makeIdentity(state, node):
        r"""makeIdentity(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_makeIdentity(state, node)

    @staticmethod
    def set(state, node):
        r"""set(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_set(state, node)

    @staticmethod
    def mult(state, node):
        r"""mult(SoState state, SoNode node)"""
        return _coin.SoBumpMapMatrixElement_mult(state, node)

    @staticmethod
    def translateBy(state, node, translation):
        r"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoBumpMapMatrixElement_translateBy(state, node, translation)

    @staticmethod
    def rotateBy(state, node, rotation):
        r"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoBumpMapMatrixElement_rotateBy(state, node, rotation)

    @staticmethod
    def scaleBy(state, node, scaleFactor):
        r"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoBumpMapMatrixElement_get(state)

# Register SoBumpMapMatrixElement in _coin:
_coin.SoBumpMapMatrixElement_swigregister(SoBumpMapMatrixElement)
class SoCacheElement(SoElement):
    r"""Proxy of C++ SoCacheElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCacheElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoCacheElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoCacheElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCacheElement_initClass()

    def init(self, state):
        r"""init(SoCacheElement self, SoState state)"""
        return _coin.SoCacheElement_init(self, state)

    def push(self, state):
        r"""push(SoCacheElement self, SoState state)"""
        return _coin.SoCacheElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoCacheElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoCacheElement_pop(self, state, prevTopElement)

    @staticmethod
    def set(state, cache):
        r"""set(SoState state, SoCache cache)"""
        return _coin.SoCacheElement_set(state, cache)

    def getCache(self):
        r"""getCache(SoCacheElement self) -> SoCache"""
        return _coin.SoCacheElement_getCache(self)

    @staticmethod
    def anyOpen(state):
        r"""anyOpen(SoState state) -> SbBool"""
        return _coin.SoCacheElement_anyOpen(state)

    @staticmethod
    def invalidate(state):
        r"""invalidate(SoState state)"""
        return _coin.SoCacheElement_invalidate(state)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoCacheElement self) -> SoElement"""
        return _coin.SoCacheElement_copyMatchInfo(self)

    def getNextCacheElement(self):
        r"""getNextCacheElement(SoCacheElement self) -> SoCacheElement"""
        return _coin.SoCacheElement_getNextCacheElement(self)

    @staticmethod
    def addElement(state, element):
        r"""addElement(SoState state, SoElement element)"""
        return _coin.SoCacheElement_addElement(state, element)

    @staticmethod
    def addCacheDependency(state, cache):
        r"""addCacheDependency(SoState state, SoCache cache)"""
        return _coin.SoCacheElement_addCacheDependency(state, cache)

    @staticmethod
    def setInvalid(newvalue):
        r"""setInvalid(SbBool const newvalue) -> SbBool"""
        return _coin.SoCacheElement_setInvalid(newvalue)

    @staticmethod
    def getCurrentCache(state):
        r"""getCurrentCache(SoState state) -> SoCache"""
        return _coin.SoCacheElement_getCurrentCache(state)

# Register SoCacheElement in _coin:
_coin.SoCacheElement_swigregister(SoCacheElement)
class SbPlane(object):
    r"""Proxy of C++ SbPlane class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbPlane_swiginit(self, _coin.new_SbPlane(*args))

    def offset(self, d):
        r"""offset(SbPlane self, float const d)"""
        return _coin.SbPlane_offset(self, d)

    def transform(self):
        r"""transform(SbPlane self)"""
        return _coin.SbPlane_transform(self)

    def isInHalfSpace(self, point):
        r"""isInHalfSpace(SbPlane self, SbVec3f point) -> SbBool"""
        return _coin.SbPlane_isInHalfSpace(self, point)

    def getDistance(self, point):
        r"""getDistance(SbPlane self, SbVec3f point) -> float"""
        return _coin.SbPlane_getDistance(self, point)

    def getNormal(self):
        r"""getNormal(SbPlane self) -> SbVec3f"""
        return _coin.SbPlane_getNormal(self)

    def getDistanceFromOrigin(self):
        r"""getDistanceFromOrigin(SbPlane self) -> float"""
        return _coin.SbPlane_getDistanceFromOrigin(self)

    def output(self, file):
        r"""output(SbPlane self, FILE * file)"""
        return _coin.SbPlane_output(self, file)

    def __eq__(self, u):
        r"""__eq__(SbPlane self, SbPlane u) -> int"""
        return _coin.SbPlane___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbPlane self, SbPlane u) -> int"""
        return _coin.SbPlane___ne__(self, u)

    def intersect(self, *args):
        r"""intersect(SbPlane) -> SbLineintersect(SbPlane) -> SbLine"""
        return _coin.SbPlane_intersect(self, *args)
    __swig_destroy__ = _coin.delete_SbPlane

# Register SbPlane in _coin:
_coin.SbPlane_swigregister(SbPlane)
class SoClipPlaneElement(SoAccumulatedElement):
    r"""Proxy of C++ SoClipPlaneElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoClipPlaneElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoClipPlaneElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoClipPlaneElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoClipPlaneElement_initClass()

    def init(self, state):
        r"""init(SoClipPlaneElement self, SoState state)"""
        return _coin.SoClipPlaneElement_init(self, state)

    def push(self, state):
        r"""push(SoClipPlaneElement self, SoState state)"""
        return _coin.SoClipPlaneElement_push(self, state)

    @staticmethod
    def add(state, node, plane):
        r"""add(SoState state, SoNode node, SbPlane plane)"""
        return _coin.SoClipPlaneElement_add(state, node, plane)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoClipPlaneElement"""
        return _coin.SoClipPlaneElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoClipPlaneElement self) -> int"""
        return _coin.SoClipPlaneElement_getNum(self)

    def get(self, index, inworldspace=1):
        r"""get(SoClipPlaneElement self, int const index, SbBool const inworldspace=1) -> SbPlane"""
        return _coin.SoClipPlaneElement_get(self, index, inworldspace)

# Register SoClipPlaneElement in _coin:
_coin.SoClipPlaneElement_swigregister(SoClipPlaneElement)
class SoFloatElement(SoElement):
    r"""Proxy of C++ SoFloatElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFloatElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoFloatElement_getClassStackIndex()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFloatElement_initClass()

    def init(self, state):
        r"""init(SoFloatElement self, SoState state)"""
        return _coin.SoFloatElement_init(self, state)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoFloatElement self) -> SoElement"""
        return _coin.SoFloatElement_copyMatchInfo(self)

    def output(self, file):
        r"""output(SoFloatElement self, FILE * file)"""
        return _coin.SoFloatElement_output(self, file)

    @staticmethod
    def set(*args):
        r"""
        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)

    @staticmethod
    def get(stackIndex, state):
        r"""get(int const stackIndex, SoState state) -> float"""
        return _coin.SoFloatElement_get(stackIndex, state)

    def setElt(self, value):
        r"""setElt(SoFloatElement self, float value)"""
        return _coin.SoFloatElement_setElt(self, value)

# Register SoFloatElement in _coin:
_coin.SoFloatElement_swigregister(SoFloatElement)
class SoComplexityElement(SoFloatElement):
    r"""Proxy of C++ SoComplexityElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComplexityElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoComplexityElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComplexityElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComplexityElement_initClass()

    def init(self, state):
        r"""init(SoComplexityElement self, SoState state)"""
        return _coin.SoComplexityElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoComplexityElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> float"""
        return _coin.SoComplexityElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> float"""
        return _coin.SoComplexityElement_getDefault()

# Register SoComplexityElement in _coin:
_coin.SoComplexityElement_swigregister(SoComplexityElement)
class SoCoordinateElement(SoReplacedElement):
    r"""Proxy of C++ SoCoordinateElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoCoordinateElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCoordinateElement_initClass()

    def init(self, state):
        r"""init(SoCoordinateElement self, SoState state)"""
        return _coin.SoCoordinateElement_init(self, state)

    @staticmethod
    def set3(state, node, numCoords, coords):
        r"""set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoCoordinateElement_set3(state, node, numCoords, coords)

    @staticmethod
    def set4(state, node, numCoords, coords):
        r"""set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
        return _coin.SoCoordinateElement_set4(state, node, numCoords, coords)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoCoordinateElement"""
        return _coin.SoCoordinateElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoCoordinateElement self) -> int32_t"""
        return _coin.SoCoordinateElement_getNum(self)

    def is3D(self):
        r"""is3D(SoCoordinateElement self) -> SbBool"""
        return _coin.SoCoordinateElement_is3D(self)

    def get3(self, index):
        r"""get3(SoCoordinateElement self, int const index) -> SbVec3f"""
        return _coin.SoCoordinateElement_get3(self, index)

    def get4(self, index):
        r"""get4(SoCoordinateElement self, int const index) -> SbVec4f"""
        return _coin.SoCoordinateElement_get4(self, index)

    def getArrayPtr3(self):
        r"""getArrayPtr3(SoCoordinateElement self) -> SbVec3f"""
        return _coin.SoCoordinateElement_getArrayPtr3(self)

    def getArrayPtr4(self):
        r"""getArrayPtr4(SoCoordinateElement self) -> SbVec4f"""
        return _coin.SoCoordinateElement_getArrayPtr4(self)

    @staticmethod
    def getDefault3():
        r"""getDefault3() -> SbVec3f"""
        return _coin.SoCoordinateElement_getDefault3()

    @staticmethod
    def getDefault4():
        r"""getDefault4() -> SbVec4f"""
        return _coin.SoCoordinateElement_getDefault4()

    def output(self, file):
        r"""output(SoCoordinateElement self, FILE * file)"""
        return _coin.SoCoordinateElement_output(self, file)

# Register SoCoordinateElement in _coin:
_coin.SoCoordinateElement_swigregister(SoCoordinateElement)
class SoCreaseAngleElement(SoFloatElement):
    r"""Proxy of C++ SoCreaseAngleElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCreaseAngleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoCreaseAngleElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoCreaseAngleElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCreaseAngleElement_initClass()

    def init(self, state):
        r"""init(SoCreaseAngleElement self, SoState state)"""
        return _coin.SoCreaseAngleElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoCreaseAngleElement_set(*args)

    @staticmethod
    def get(*args):
        r"""
        get(SoState state) -> float
        get(SoState state, SbBool const isvrml1) -> float
        """
        return _coin.SoCreaseAngleElement_get(*args)

    @staticmethod
    def getDefault(*args):
        r"""
        getDefault() -> float
        getDefault(SbBool const isvrml1) -> float
        """
        return _coin.SoCreaseAngleElement_getDefault(*args)

# Register SoCreaseAngleElement in _coin:
_coin.SoCreaseAngleElement_swigregister(SoCreaseAngleElement)
class SoCullElement(SoElement):
    r"""Proxy of C++ SoCullElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCullElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoCullElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoCullElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCullElement_initClass()

    def init(self, state):
        r"""init(SoCullElement self, SoState state)"""
        return _coin.SoCullElement_init(self, state)

    def push(self, state):
        r"""push(SoCullElement self, SoState state)"""
        return _coin.SoCullElement_push(self, state)

    @staticmethod
    def setViewVolume(state, vv):
        r"""setViewVolume(SoState state, SbViewVolume vv)"""
        return _coin.SoCullElement_setViewVolume(state, vv)

    @staticmethod
    def addPlane(state, newplane):
        r"""addPlane(SoState state, SbPlane newplane)"""
        return _coin.SoCullElement_addPlane(state, newplane)

    @staticmethod
    def cullBox(state, box, transform=1):
        r"""cullBox(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool"""
        return _coin.SoCullElement_cullBox(state, box, transform)

    @staticmethod
    def cullTest(state, box, transform=1):
        r"""cullTest(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool"""
        return _coin.SoCullElement_cullTest(state, box, transform)

    @staticmethod
    def completelyInside(state):
        r"""completelyInside(SoState state) -> SbBool"""
        return _coin.SoCullElement_completelyInside(state)

    def matches(self, elt):
        r"""matches(SoCullElement self, SoElement elt) -> SbBool"""
        return _coin.SoCullElement_matches(self, elt)

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoCullElement self) -> SoElement"""
        return _coin.SoCullElement_copyMatchInfo(self)

# Register SoCullElement in _coin:
_coin.SoCullElement_swigregister(SoCullElement)
class SoDecimationPercentageElement(SoFloatElement):
    r"""Proxy of C++ SoDecimationPercentageElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecimationPercentageElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoDecimationPercentageElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDecimationPercentageElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDecimationPercentageElement_initClass()

    def init(self, state):
        r"""init(SoDecimationPercentageElement self, SoState state)"""
        return _coin.SoDecimationPercentageElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const complexity)
        set(SoState state, float const complexity)
        """
        return _coin.SoDecimationPercentageElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> float"""
        return _coin.SoDecimationPercentageElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> float"""
        return _coin.SoDecimationPercentageElement_getDefault()

# Register SoDecimationPercentageElement in _coin:
_coin.SoDecimationPercentageElement_swigregister(SoDecimationPercentageElement)
class SoDiffuseColorElement(SoReplacedElement):
    r"""Proxy of C++ SoDiffuseColorElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDiffuseColorElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoDiffuseColorElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDiffuseColorElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDiffuseColorElement_initClass()

    def init(self, state):
        r"""init(SoDiffuseColorElement self, SoState state)"""
        return _coin.SoDiffuseColorElement_init(self, state)

    @staticmethod
    def set(state, node, numcolors, colors):
        r"""set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoDiffuseColorElement_set(state, node, numcolors, colors)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoDiffuseColorElement"""
        return _coin.SoDiffuseColorElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoDiffuseColorElement self) -> int32_t"""
        return _coin.SoDiffuseColorElement_getNum(self)

    def get(self, index):
        r"""get(SoDiffuseColorElement self, int const index) -> SbColor"""
        return _coin.SoDiffuseColorElement_get(self, index)

    def isPacked(self):
        r"""isPacked(SoDiffuseColorElement self) -> SbBool"""
        return _coin.SoDiffuseColorElement_isPacked(self)

    def hasPackedTransparency(self):
        r"""hasPackedTransparency(SoDiffuseColorElement self) -> SbBool"""
        return _coin.SoDiffuseColorElement_hasPackedTransparency(self)

    def getColorArrayPtr(self):
        r"""getColorArrayPtr(SoDiffuseColorElement self) -> SbColor"""
        return _coin.SoDiffuseColorElement_getColorArrayPtr(self)

    def getPackedArrayPtr(self):
        r"""getPackedArrayPtr(SoDiffuseColorElement self) -> uint32_t const *"""
        return _coin.SoDiffuseColorElement_getPackedArrayPtr(self)

# Register SoDiffuseColorElement in _coin:
_coin.SoDiffuseColorElement_swigregister(SoDiffuseColorElement)
class SoGLClipPlaneElement(SoClipPlaneElement):
    r"""Proxy of C++ SoGLClipPlaneElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLClipPlaneElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLClipPlaneElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLClipPlaneElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLClipPlaneElement_initClass()

    def init(self, state):
        r"""init(SoGLClipPlaneElement self, SoState state)"""
        return _coin.SoGLClipPlaneElement_init(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLClipPlaneElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLClipPlaneElement_pop(self, state, prevTopElement)

    @staticmethod
    def getMaxGLPlanes():
        r"""getMaxGLPlanes() -> int"""
        return _coin.SoGLClipPlaneElement_getMaxGLPlanes()

# Register SoGLClipPlaneElement in _coin:
_coin.SoGLClipPlaneElement_swigregister(SoGLClipPlaneElement)
class SoLightElement(SoAccumulatedElement):
    r"""Proxy of C++ SoLightElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoLightElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoLightElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLightElement_initClass()

    def init(self, state):
        r"""init(SoLightElement self, SoState state)"""
        return _coin.SoLightElement_init(self, state)

    def push(self, state):
        r"""push(SoLightElement self, SoState state)"""
        return _coin.SoLightElement_push(self, state)

    @staticmethod
    def add(state, light):
        r"""add(SoState state, SoLight light)"""
        return _coin.SoLightElement_add(state, light)

    @staticmethod
    def getLights(state):
        r"""getLights(SoState state) -> SoNodeList"""
        return _coin.SoLightElement_getLights(state)

    @staticmethod
    def getMatrix(state, index):
        r"""getMatrix(SoState state, int const index) -> SbMatrix"""
        return _coin.SoLightElement_getMatrix(state, index)

# Register SoLightElement in _coin:
_coin.SoLightElement_swigregister(SoLightElement)
class SoGLModelMatrixElement(SoModelMatrixElement):
    r"""Proxy of C++ SoGLModelMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLModelMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLModelMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLModelMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLModelMatrixElement_initClass()

    def init(self, state):
        r"""init(SoGLModelMatrixElement self, SoState state)"""
        return _coin.SoGLModelMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoGLModelMatrixElement self, SoState state)"""
        return _coin.SoGLModelMatrixElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLModelMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLModelMatrixElement_pop(self, state, prevTopElement)

# Register SoGLModelMatrixElement in _coin:
_coin.SoGLModelMatrixElement_swigregister(SoGLModelMatrixElement)
class SoProfileElement(SoAccumulatedElement):
    r"""Proxy of C++ SoProfileElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfileElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoProfileElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoProfileElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoProfileElement_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):
        r"""init(SoProfileElement self, SoState state)"""
        return _coin.SoProfileElement_init(self, state)

    def push(self, state):
        r"""push(SoProfileElement self, SoState state)"""
        return _coin.SoProfileElement_push(self, state)

    @staticmethod
    def add(state, profile):
        r"""add(SoState state, SoProfile profile)"""
        return _coin.SoProfileElement_add(state, profile)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoNodeList"""
        return _coin.SoProfileElement_get(state)

# Register SoProfileElement in _coin:
_coin.SoProfileElement_swigregister(SoProfileElement)
class SoTextureMatrixElement(SoAccumulatedElement):
    r"""Proxy of C++ SoTextureMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureMatrixElement_initClass()

    def init(self, state):
        r"""init(SoTextureMatrixElement self, SoState state)"""
        return _coin.SoTextureMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoTextureMatrixElement self, SoState state)"""
        return _coin.SoTextureMatrixElement_push(self, state)

    @staticmethod
    def makeIdentity(state, node):
        r"""makeIdentity(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_makeIdentity(state, node)

    @staticmethod
    def set(state, node):
        r"""set(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_set(state, node)

    @staticmethod
    def mult(state, node):
        r"""mult(SoState state, SoNode node)"""
        return _coin.SoTextureMatrixElement_mult(state, node)

    @staticmethod
    def translateBy(state, node, translation):
        r"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
        return _coin.SoTextureMatrixElement_translateBy(state, node, translation)

    @staticmethod
    def rotateBy(state, node, rotation):
        r"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
        return _coin.SoTextureMatrixElement_rotateBy(state, node, rotation)

    @staticmethod
    def scaleBy(state, node, scaleFactor):
        r"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
        return _coin.SoTextureMatrixElement_scaleBy(state, node, scaleFactor)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoTextureMatrixElement_get(state)

    @staticmethod
    def emptyMatrix(state):
        r"""emptyMatrix(SoState state)"""
        return _coin.SoTextureMatrixElement_emptyMatrix(state)

# Register SoTextureMatrixElement in _coin:
_coin.SoTextureMatrixElement_swigregister(SoTextureMatrixElement)
class SoGLTextureMatrixElement(SoTextureMatrixElement):
    r"""Proxy of C++ SoGLTextureMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLTextureMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLTextureMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLTextureMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLTextureMatrixElement_initClass()

    def init(self, state):
        r"""init(SoGLTextureMatrixElement self, SoState state)"""
        return _coin.SoGLTextureMatrixElement_init(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLTextureMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureMatrixElement_pop(self, state, prevTopElement)

    @staticmethod
    def setEltIdentity():
        r"""setEltIdentity()"""
        return _coin.SoGLTextureMatrixElement_setEltIdentity()

    def setElt(self):
        r"""setElt(SoGLTextureMatrixElement self)"""
        return _coin.SoGLTextureMatrixElement_setElt(self)

    def makeEltIdentity(self):
        r"""makeEltIdentity(SoGLTextureMatrixElement self)"""
        return _coin.SoGLTextureMatrixElement_makeEltIdentity(self)

    def multElt(self):
        r"""multElt(SoGLTextureMatrixElement self)"""
        return _coin.SoGLTextureMatrixElement_multElt(self)

    def translateEltBy(self, translation):
        r"""translateEltBy(SoGLTextureMatrixElement self, SbVec3f translation)"""
        return _coin.SoGLTextureMatrixElement_translateEltBy(self, translation)

    def rotateEltBy(self, translation):
        r"""rotateEltBy(SoGLTextureMatrixElement self, SbRotation translation)"""
        return _coin.SoGLTextureMatrixElement_rotateEltBy(self, translation)

    def scaleEltBy(self, scaleFactor):
        r"""scaleEltBy(SoGLTextureMatrixElement self, SbVec3f scaleFactor)"""
        return _coin.SoGLTextureMatrixElement_scaleEltBy(self, scaleFactor)

# Register SoGLTextureMatrixElement in _coin:
_coin.SoGLTextureMatrixElement_swigregister(SoGLTextureMatrixElement)
class SoGLDrawStyleElement(SoDrawStyleElement):
    r"""Proxy of C++ SoGLDrawStyleElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLDrawStyleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLDrawStyleElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLDrawStyleElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLDrawStyleElement_initClass()

    def init(self, state):
        r"""init(SoGLDrawStyleElement self, SoState state)"""
        return _coin.SoGLDrawStyleElement_init(self, state)

    def push(self, state):
        r"""push(SoGLDrawStyleElement self, SoState state)"""
        return _coin.SoGLDrawStyleElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLDrawStyleElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLDrawStyleElement_pop(self, state, prevTopElement)

# Register SoGLDrawStyleElement in _coin:
_coin.SoGLDrawStyleElement_swigregister(SoGLDrawStyleElement)
class SoGLLightIdElement(SoInt32Element):
    r"""Proxy of C++ SoGLLightIdElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLLightIdElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLLightIdElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLLightIdElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLLightIdElement_initClass()

    def init(self, state):
        r"""init(SoGLLightIdElement self, SoState state)"""
        return _coin.SoGLLightIdElement_init(self, state)

    def push(self, state):
        r"""push(SoGLLightIdElement self, SoState state)"""
        return _coin.SoGLLightIdElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLLightIdElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLightIdElement_pop(self, state, prevTopElement)

    @staticmethod
    def increment(*args):
        r"""
        increment(SoState state, SoNode node) -> int32_t
        increment(SoState state) -> int32_t
        """
        return _coin.SoGLLightIdElement_increment(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> int32_t"""
        return _coin.SoGLLightIdElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> int32_t"""
        return _coin.SoGLLightIdElement_getDefault()

    @staticmethod
    def getMaxGLSources():
        r"""getMaxGLSources() -> int32_t"""
        return _coin.SoGLLightIdElement_getMaxGLSources()

# Register SoGLLightIdElement in _coin:
_coin.SoGLLightIdElement_swigregister(SoGLLightIdElement)
class SoTextureEnabledElement(SoInt32Element):
    r"""Proxy of C++ SoTextureEnabledElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureEnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureEnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureEnabledElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureEnabledElement_initClass()

    def init(self, state):
        r"""init(SoTextureEnabledElement self, SoState state)"""
        return _coin.SoTextureEnabledElement_init(self, state)

    @staticmethod
    def set(state, node, enabled):
        r"""set(SoState state, SoNode node, SbBool const enabled)"""
        return _coin.SoTextureEnabledElement_set(state, node, enabled)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbBool"""
        return _coin.SoTextureEnabledElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SbBool"""
        return _coin.SoTextureEnabledElement_getDefault()

    def setElt(self, value):
        r"""setElt(SoTextureEnabledElement self, int32_t value)"""
        return _coin.SoTextureEnabledElement_setElt(self, value)

# Register SoTextureEnabledElement in _coin:
_coin.SoTextureEnabledElement_swigregister(SoTextureEnabledElement)
class SoGLTextureEnabledElement(SoTextureEnabledElement):
    r"""Proxy of C++ SoGLTextureEnabledElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLTextureEnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLTextureEnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLTextureEnabledElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLTextureEnabledElement_initClass()
    DISABLED = _coin.SoGLTextureEnabledElement_DISABLED
    
    TEXTURE2D = _coin.SoGLTextureEnabledElement_TEXTURE2D
    
    RECTANGLE = _coin.SoGLTextureEnabledElement_RECTANGLE
    
    CUBEMAP = _coin.SoGLTextureEnabledElement_CUBEMAP
    

    def init(self, state):
        r"""init(SoGLTextureEnabledElement self, SoState state)"""
        return _coin.SoGLTextureEnabledElement_init(self, state)

    def push(self, state):
        r"""push(SoGLTextureEnabledElement self, SoState state)"""
        return _coin.SoGLTextureEnabledElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLTextureEnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureEnabledElement_pop(self, state, prevTopElement)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, SbBool const enabled)
        set(SoState state, SbBool const enabled)
        """
        return _coin.SoGLTextureEnabledElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbBool"""
        return _coin.SoGLTextureEnabledElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SbBool"""
        return _coin.SoGLTextureEnabledElement_getDefault()

    def setElt(self, value):
        r"""setElt(SoGLTextureEnabledElement self, int32_t value)"""
        return _coin.SoGLTextureEnabledElement_setElt(self, value)

    @staticmethod
    def enableRectangle(state, node):
        r"""enableRectangle(SoState state, SoNode node)"""
        return _coin.SoGLTextureEnabledElement_enableRectangle(state, node)

    @staticmethod
    def enableCubeMap(state, node):
        r"""enableCubeMap(SoState state, SoNode node)"""
        return _coin.SoGLTextureEnabledElement_enableCubeMap(state, node)

    @staticmethod
    def getMode(state):
        r"""getMode(SoState state) -> SoGLTextureEnabledElement::Mode"""
        return _coin.SoGLTextureEnabledElement_getMode(state)

# Register SoGLTextureEnabledElement in _coin:
_coin.SoGLTextureEnabledElement_swigregister(SoGLTextureEnabledElement)
class SoTexture3EnabledElement(SoInt32Element):
    r"""Proxy of C++ SoTexture3EnabledElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture3EnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTexture3EnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTexture3EnabledElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTexture3EnabledElement_initClass()

    def init(self, state):
        r"""init(SoTexture3EnabledElement self, SoState state)"""
        return _coin.SoTexture3EnabledElement_init(self, state)

    @staticmethod
    def set(state, node, enabled):
        r"""set(SoState state, SoNode node, SbBool const enabled)"""
        return _coin.SoTexture3EnabledElement_set(state, node, enabled)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbBool"""
        return _coin.SoTexture3EnabledElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SbBool"""
        return _coin.SoTexture3EnabledElement_getDefault()

    def setElt(self, value):
        r"""setElt(SoTexture3EnabledElement self, int32_t value)"""
        return _coin.SoTexture3EnabledElement_setElt(self, value)

# Register SoTexture3EnabledElement in _coin:
_coin.SoTexture3EnabledElement_swigregister(SoTexture3EnabledElement)
class SoGLTexture3EnabledElement(SoTexture3EnabledElement):
    r"""Proxy of C++ SoGLTexture3EnabledElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLTexture3EnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLTexture3EnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLTexture3EnabledElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLTexture3EnabledElement_initClass()

    def init(self, state):
        r"""init(SoGLTexture3EnabledElement self, SoState state)"""
        return _coin.SoGLTexture3EnabledElement_init(self, state)

    def push(self, state):
        r"""push(SoGLTexture3EnabledElement self, SoState state)"""
        return _coin.SoGLTexture3EnabledElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLTexture3EnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTexture3EnabledElement_pop(self, state, prevTopElement)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, SbBool const enabled)
        set(SoState state, SbBool const enabled)
        """
        return _coin.SoGLTexture3EnabledElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbBool"""
        return _coin.SoGLTexture3EnabledElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SbBool"""
        return _coin.SoGLTexture3EnabledElement_getDefault()

    def setElt(self, value):
        r"""setElt(SoGLTexture3EnabledElement self, int32_t value)"""
        return _coin.SoGLTexture3EnabledElement_setElt(self, value)

# Register SoGLTexture3EnabledElement in _coin:
_coin.SoGLTexture3EnabledElement_swigregister(SoGLTexture3EnabledElement)
class SoLinePatternElement(SoInt32Element):
    r"""Proxy of C++ SoLinePatternElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLinePatternElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoLinePatternElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoLinePatternElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLinePatternElement_initClass()
    CONTINUOUS = _coin.SoLinePatternElement_CONTINUOUS
    

    def init(self, state):
        r"""init(SoLinePatternElement self, SoState state)"""
        return _coin.SoLinePatternElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, int32_t const pattern)
        set(SoState state, int32_t const pattern)
        """
        return _coin.SoLinePatternElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> int32_t"""
        return _coin.SoLinePatternElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> int32_t"""
        return _coin.SoLinePatternElement_getDefault()

# Register SoLinePatternElement in _coin:
_coin.SoLinePatternElement_swigregister(SoLinePatternElement)
class SoGLLinePatternElement(SoLinePatternElement):
    r"""Proxy of C++ SoGLLinePatternElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLLinePatternElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLLinePatternElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLLinePatternElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLLinePatternElement_initClass()

    def init(self, state):
        r"""init(SoGLLinePatternElement self, SoState state)"""
        return _coin.SoGLLinePatternElement_init(self, state)

    def push(self, state):
        r"""push(SoGLLinePatternElement self, SoState state)"""
        return _coin.SoGLLinePatternElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLLinePatternElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLinePatternElement_pop(self, state, prevTopElement)

# Register SoGLLinePatternElement in _coin:
_coin.SoGLLinePatternElement_swigregister(SoGLLinePatternElement)
class SoSwitchElement(SoInt32Element):
    r"""Proxy of C++ SoSwitchElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSwitchElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoSwitchElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSwitchElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSwitchElement_initClass()

    def init(self, state):
        r"""init(SoSwitchElement self, SoState state)"""
        return _coin.SoSwitchElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, int32_t const index)
        set(SoState state, int32_t const index)
        """
        return _coin.SoSwitchElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> int32_t"""
        return _coin.SoSwitchElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> int32_t"""
        return _coin.SoSwitchElement_getDefault()

# Register SoSwitchElement in _coin:
_coin.SoSwitchElement_swigregister(SoSwitchElement)
class SoTextOutlineEnabledElement(SoInt32Element):
    r"""Proxy of C++ SoTextOutlineEnabledElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextOutlineEnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextOutlineEnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextOutlineEnabledElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextOutlineEnabledElement_initClass()

    def init(self, state):
        r"""init(SoTextOutlineEnabledElement self, SoState state)"""
        return _coin.SoTextOutlineEnabledElement_init(self, state)

    def push(self, state):
        r"""push(SoTextOutlineEnabledElement self, SoState state)"""
        return _coin.SoTextOutlineEnabledElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoTextOutlineEnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoTextOutlineEnabledElement_pop(self, state, prevTopElement)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, SbBool const enabled)
        set(SoState state, SbBool const enabled)
        """
        return _coin.SoTextOutlineEnabledElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbBool"""
        return _coin.SoTextOutlineEnabledElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SbBool"""
        return _coin.SoTextOutlineEnabledElement_getDefault()

# Register SoTextOutlineEnabledElement in _coin:
_coin.SoTextOutlineEnabledElement_swigregister(SoTextOutlineEnabledElement)
class SoUnitsElement(SoInt32Element):
    r"""Proxy of C++ SoUnitsElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoUnitsElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoUnitsElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoUnitsElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoUnitsElement_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):
        r"""init(SoUnitsElement self, SoState state)"""
        return _coin.SoUnitsElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, SoUnitsElement::Units const units)
        set(SoState state, SoUnitsElement::Units const units)
        """
        return _coin.SoUnitsElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoUnitsElement::Units"""
        return _coin.SoUnitsElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoUnitsElement::Units"""
        return _coin.SoUnitsElement_getDefault()

# Register SoUnitsElement in _coin:
_coin.SoUnitsElement_swigregister(SoUnitsElement)
class SoFocalDistanceElement(SoFloatElement):
    r"""Proxy of C++ SoFocalDistanceElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFocalDistanceElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoFocalDistanceElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoFocalDistanceElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFocalDistanceElement_initClass()

    def init(self, state):
        r"""init(SoFocalDistanceElement self, SoState state)"""
        return _coin.SoFocalDistanceElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const distance)
        set(SoState state, float const distance)
        """
        return _coin.SoFocalDistanceElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> float"""
        return _coin.SoFocalDistanceElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> float"""
        return _coin.SoFocalDistanceElement_getDefault()

# Register SoFocalDistanceElement in _coin:
_coin.SoFocalDistanceElement_swigregister(SoFocalDistanceElement)
class SoFontSizeElement(SoFloatElement):
    r"""Proxy of C++ SoFontSizeElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFontSizeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoFontSizeElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoFontSizeElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFontSizeElement_initClass()

    def init(self, state):
        r"""init(SoFontSizeElement self, SoState state)"""
        return _coin.SoFontSizeElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const fontSize)
        set(SoState state, float const fontSize)
        """
        return _coin.SoFontSizeElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> float"""
        return _coin.SoFontSizeElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> float"""
        return _coin.SoFontSizeElement_getDefault()

# Register SoFontSizeElement in _coin:
_coin.SoFontSizeElement_swigregister(SoFontSizeElement)
class SoLineWidthElement(SoFloatElement):
    r"""Proxy of C++ SoLineWidthElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLineWidthElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoLineWidthElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoLineWidthElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLineWidthElement_initClass()

    def init(self, state):
        r"""init(SoLineWidthElement self, SoState state)"""
        return _coin.SoLineWidthElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const lineWidth)
        set(SoState state, float const lineWidth)
        """
        return _coin.SoLineWidthElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> float"""
        return _coin.SoLineWidthElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> float"""
        return _coin.SoLineWidthElement_getDefault()

# Register SoLineWidthElement in _coin:
_coin.SoLineWidthElement_swigregister(SoLineWidthElement)
class SoGLLineWidthElement(SoLineWidthElement):
    r"""Proxy of C++ SoGLLineWidthElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLLineWidthElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLLineWidthElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLLineWidthElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLLineWidthElement_initClass()

    def init(self, state):
        r"""init(SoGLLineWidthElement self, SoState state)"""
        return _coin.SoGLLineWidthElement_init(self, state)

    def push(self, state):
        r"""push(SoGLLineWidthElement self, SoState state)"""
        return _coin.SoGLLineWidthElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLLineWidthElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLLineWidthElement_pop(self, state, prevTopElement)

# Register SoGLLineWidthElement in _coin:
_coin.SoGLLineWidthElement_swigregister(SoGLLineWidthElement)
class SoPointSizeElement(SoFloatElement):
    r"""Proxy of C++ SoPointSizeElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointSizeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoPointSizeElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoPointSizeElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPointSizeElement_initClass()

    def init(self, state):
        r"""init(SoPointSizeElement self, SoState state)"""
        return _coin.SoPointSizeElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const pointSize)
        set(SoState state, float const pointSize)
        """
        return _coin.SoPointSizeElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> float"""
        return _coin.SoPointSizeElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> float"""
        return _coin.SoPointSizeElement_getDefault()

# Register SoPointSizeElement in _coin:
_coin.SoPointSizeElement_swigregister(SoPointSizeElement)
class SoGLPointSizeElement(SoPointSizeElement):
    r"""Proxy of C++ SoGLPointSizeElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLPointSizeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLPointSizeElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLPointSizeElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLPointSizeElement_initClass()

    def init(self, state):
        r"""init(SoGLPointSizeElement self, SoState state)"""
        return _coin.SoGLPointSizeElement_init(self, state)

    def push(self, state):
        r"""push(SoGLPointSizeElement self, SoState state)"""
        return _coin.SoGLPointSizeElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLPointSizeElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLPointSizeElement_pop(self, state, prevTopElement)

# Register SoGLPointSizeElement in _coin:
_coin.SoGLPointSizeElement_swigregister(SoGLPointSizeElement)
class SoTextureQualityElement(SoFloatElement):
    r"""Proxy of C++ SoTextureQualityElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureQualityElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureQualityElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureQualityElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureQualityElement_initClass()

    def init(self, state):
        r"""init(SoTextureQualityElement self, SoState state)"""
        return _coin.SoTextureQualityElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const quality)
        set(SoState state, float const quality)
        """
        return _coin.SoTextureQualityElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> float"""
        return _coin.SoTextureQualityElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> float"""
        return _coin.SoTextureQualityElement_getDefault()

# Register SoTextureQualityElement in _coin:
_coin.SoTextureQualityElement_swigregister(SoTextureQualityElement)
class SoTextureOverrideElement(SoElement):
    r"""Proxy of C++ SoTextureOverrideElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureOverrideElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureOverrideElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureOverrideElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureOverrideElement_initClass()

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoTextureOverrideElement self) -> SoElement"""
        return _coin.SoTextureOverrideElement_copyMatchInfo(self)

    def init(self, state):
        r"""init(SoTextureOverrideElement self, SoState state)"""
        return _coin.SoTextureOverrideElement_init(self, state)

    def push(self, state):
        r"""push(SoTextureOverrideElement self, SoState state)"""
        return _coin.SoTextureOverrideElement_push(self, state)

    @staticmethod
    def getQualityOverride(state):
        r"""getQualityOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getQualityOverride(state)

    @staticmethod
    def getImageOverride(state):
        r"""getImageOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getImageOverride(state)

    @staticmethod
    def getBumpMapOverride(state):
        r"""getBumpMapOverride(SoState state) -> SbBool"""
        return _coin.SoTextureOverrideElement_getBumpMapOverride(state)

    @staticmethod
    def setQualityOverride(state, value):
        r"""setQualityOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setQualityOverride(state, value)

    @staticmethod
    def setImageOverride(state, value):
        r"""setImageOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setImageOverride(state, value)

    @staticmethod
    def setBumpMapOverride(state, value):
        r"""setBumpMapOverride(SoState state, SbBool const value)"""
        return _coin.SoTextureOverrideElement_setBumpMapOverride(state, value)

    def output(self, fp):
        r"""output(SoTextureOverrideElement self, FILE * fp)"""
        return _coin.SoTextureOverrideElement_output(self, fp)

# Register SoTextureOverrideElement in _coin:
_coin.SoTextureOverrideElement_swigregister(SoTextureOverrideElement)
class SoGLRenderPassElement(SoElement):
    r"""Proxy of C++ SoGLRenderPassElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLRenderPassElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLRenderPassElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLRenderPassElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLRenderPassElement_initClass()

    def init(self, state):
        r"""init(SoGLRenderPassElement self, SoState state)"""
        return _coin.SoGLRenderPassElement_init(self, state)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoGLRenderPassElement self) -> SoElement"""
        return _coin.SoGLRenderPassElement_copyMatchInfo(self)

    @staticmethod
    def set(state, passNumber):
        r"""set(SoState state, int const passNumber)"""
        return _coin.SoGLRenderPassElement_set(state, passNumber)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> int"""
        return _coin.SoGLRenderPassElement_get(state)

# Register SoGLRenderPassElement in _coin:
_coin.SoGLRenderPassElement_swigregister(SoGLRenderPassElement)
class SoGLUpdateAreaElement(SoElement):
    r"""Proxy of C++ SoGLUpdateAreaElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLUpdateAreaElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLUpdateAreaElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLUpdateAreaElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLUpdateAreaElement_initClass()

    def init(self, state):
        r"""init(SoGLUpdateAreaElement self, SoState state)"""
        return _coin.SoGLUpdateAreaElement_init(self, state)

    def push(self, state):
        r"""push(SoGLUpdateAreaElement self, SoState state)"""
        return _coin.SoGLUpdateAreaElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLUpdateAreaElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLUpdateAreaElement_pop(self, state, prevTopElement)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoGLUpdateAreaElement self) -> SoElement"""
        return _coin.SoGLUpdateAreaElement_copyMatchInfo(self)

    @staticmethod
    def set(state, origin, size):
        r"""set(SoState state, SbVec2f origin, SbVec2f size)"""
        return _coin.SoGLUpdateAreaElement_set(state, origin, size)

    @staticmethod
    def get(state, origin, size):
        r"""get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
        return _coin.SoGLUpdateAreaElement_get(state, origin, size)

    @staticmethod
    def getDefaultOrigin():
        r"""getDefaultOrigin() -> SbVec2f"""
        return _coin.SoGLUpdateAreaElement_getDefaultOrigin()

    @staticmethod
    def getDefaultSize():
        r"""getDefaultSize() -> SbVec2f"""
        return _coin.SoGLUpdateAreaElement_getDefaultSize()

# Register SoGLUpdateAreaElement in _coin:
_coin.SoGLUpdateAreaElement_swigregister(SoGLUpdateAreaElement)
class SoLocalBBoxMatrixElement(SoElement):
    r"""Proxy of C++ SoLocalBBoxMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLocalBBoxMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoLocalBBoxMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoLocalBBoxMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLocalBBoxMatrixElement_initClass()

    def init(self, state):
        r"""init(SoLocalBBoxMatrixElement self, SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoLocalBBoxMatrixElement self, SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_push(self, state)

    @staticmethod
    def makeIdentity(state):
        r"""makeIdentity(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_makeIdentity(state)

    @staticmethod
    def set(state):
        r"""set(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_set(state)

    @staticmethod
    def mult(state):
        r"""mult(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_mult(state)

    @staticmethod
    def translateBy(state, translation):
        r"""translateBy(SoState state, SbVec3f translation)"""
        return _coin.SoLocalBBoxMatrixElement_translateBy(state, translation)

    @staticmethod
    def rotateBy(state, rotation):
        r"""rotateBy(SoState state, SbRotation rotation)"""
        return _coin.SoLocalBBoxMatrixElement_rotateBy(state, rotation)

    @staticmethod
    def scaleBy(state, scaleFactor):
        r"""scaleBy(SoState state, SbVec3f scaleFactor)"""
        return _coin.SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor)

    @staticmethod
    def pushMatrix(state):
        r"""pushMatrix(SoState state) -> SbMatrix"""
        return _coin.SoLocalBBoxMatrixElement_pushMatrix(state)

    @staticmethod
    def popMatrix(state):
        r"""popMatrix(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_popMatrix(state)

    @staticmethod
    def resetAll(state):
        r"""resetAll(SoState state)"""
        return _coin.SoLocalBBoxMatrixElement_resetAll(state)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoLocalBBoxMatrixElement_get(state)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoLocalBBoxMatrixElement self) -> SoElement"""
        return _coin.SoLocalBBoxMatrixElement_copyMatchInfo(self)

# Register SoLocalBBoxMatrixElement in _coin:
_coin.SoLocalBBoxMatrixElement_swigregister(SoLocalBBoxMatrixElement)
class SoOverrideElement(SoElement):
    r"""Proxy of C++ SoOverrideElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoOverrideElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoOverrideElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoOverrideElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoOverrideElement_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):
        r"""init(SoOverrideElement self, SoState state)"""
        return _coin.SoOverrideElement_init(self, state)

    def push(self, state):
        r"""push(SoOverrideElement self, SoState state)"""
        return _coin.SoOverrideElement_push(self, state)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoOverrideElement self) -> SoElement"""
        return _coin.SoOverrideElement_copyMatchInfo(self)

    @staticmethod
    def getFlags(state):
        r"""getFlags(SoState state) -> uint32_t"""
        return _coin.SoOverrideElement_getFlags(state)

    @staticmethod
    def getAmbientColorOverride(state):
        r"""getAmbientColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getAmbientColorOverride(state)

    @staticmethod
    def getColorIndexOverride(state):
        r"""getColorIndexOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getColorIndexOverride(state)

    @staticmethod
    def getComplexityOverride(state):
        r"""getComplexityOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getComplexityOverride(state)

    @staticmethod
    def getComplexityTypeOverride(state):
        r"""getComplexityTypeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getComplexityTypeOverride(state)

    @staticmethod
    def getCreaseAngleOverride(state):
        r"""getCreaseAngleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getCreaseAngleOverride(state)

    @staticmethod
    def getDiffuseColorOverride(state):
        r"""getDiffuseColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getDiffuseColorOverride(state)

    @staticmethod
    def getDrawStyleOverride(state):
        r"""getDrawStyleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getDrawStyleOverride(state)

    @staticmethod
    def getEmissiveColorOverride(state):
        r"""getEmissiveColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getEmissiveColorOverride(state)

    @staticmethod
    def getFontNameOverride(state):
        r"""getFontNameOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getFontNameOverride(state)

    @staticmethod
    def getFontSizeOverride(state):
        r"""getFontSizeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getFontSizeOverride(state)

    @staticmethod
    def getLightModelOverride(state):
        r"""getLightModelOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLightModelOverride(state)

    @staticmethod
    def getLinePatternOverride(state):
        r"""getLinePatternOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLinePatternOverride(state)

    @staticmethod
    def getLineWidthOverride(state):
        r"""getLineWidthOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getLineWidthOverride(state)

    @staticmethod
    def getMaterialBindingOverride(state):
        r"""getMaterialBindingOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getMaterialBindingOverride(state)

    @staticmethod
    def getPickStyleOverride(state):
        r"""getPickStyleOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPickStyleOverride(state)

    @staticmethod
    def getPointSizeOverride(state):
        r"""getPointSizeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPointSizeOverride(state)

    @staticmethod
    def getPolygonOffsetOverride(state):
        r"""getPolygonOffsetOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getPolygonOffsetOverride(state)

    @staticmethod
    def getShapeHintsOverride(state):
        r"""getShapeHintsOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getShapeHintsOverride(state)

    @staticmethod
    def getShininessOverride(state):
        r"""getShininessOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getShininessOverride(state)

    @staticmethod
    def getSpecularColorOverride(state):
        r"""getSpecularColorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getSpecularColorOverride(state)

    @staticmethod
    def getTransparencyOverride(state):
        r"""getTransparencyOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getTransparencyOverride(state)

    @staticmethod
    def getTransparencyTypeOverride(state):
        r"""getTransparencyTypeOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getTransparencyTypeOverride(state)

    @staticmethod
    def getNormalVectorOverride(state):
        r"""getNormalVectorOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getNormalVectorOverride(state)

    @staticmethod
    def getNormalBindingOverride(state):
        r"""getNormalBindingOverride(SoState state) -> SbBool"""
        return _coin.SoOverrideElement_getNormalBindingOverride(state)

    @staticmethod
    def setAmbientColorOverride(state, node, override):
        r"""setAmbientColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setAmbientColorOverride(state, node, override)

    @staticmethod
    def setColorIndexOverride(state, node, override):
        r"""setColorIndexOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setColorIndexOverride(state, node, override)

    @staticmethod
    def setComplexityOverride(state, node, override):
        r"""setComplexityOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setComplexityOverride(state, node, override)

    @staticmethod
    def setComplexityTypeOverride(state, node, override):
        r"""setComplexityTypeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setComplexityTypeOverride(state, node, override)

    @staticmethod
    def setCreaseAngleOverride(state, node, override):
        r"""setCreaseAngleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setCreaseAngleOverride(state, node, override)

    @staticmethod
    def setDiffuseColorOverride(state, node, override):
        r"""setDiffuseColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setDiffuseColorOverride(state, node, override)

    @staticmethod
    def setDrawStyleOverride(state, node, override):
        r"""setDrawStyleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setDrawStyleOverride(state, node, override)

    @staticmethod
    def setEmissiveColorOverride(state, node, override):
        r"""setEmissiveColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setEmissiveColorOverride(state, node, override)

    @staticmethod
    def setFontNameOverride(state, node, override):
        r"""setFontNameOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setFontNameOverride(state, node, override)

    @staticmethod
    def setFontSizeOverride(state, node, override):
        r"""setFontSizeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setFontSizeOverride(state, node, override)

    @staticmethod
    def setLightModelOverride(state, node, override):
        r"""setLightModelOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLightModelOverride(state, node, override)

    @staticmethod
    def setLinePatternOverride(state, node, override):
        r"""setLinePatternOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLinePatternOverride(state, node, override)

    @staticmethod
    def setLineWidthOverride(state, node, override):
        r"""setLineWidthOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setLineWidthOverride(state, node, override)

    @staticmethod
    def setMaterialBindingOverride(state, node, override):
        r"""setMaterialBindingOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setMaterialBindingOverride(state, node, override)

    @staticmethod
    def setPickStyleOverride(state, node, override):
        r"""setPickStyleOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPickStyleOverride(state, node, override)

    @staticmethod
    def setPointSizeOverride(state, node, override):
        r"""setPointSizeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPointSizeOverride(state, node, override)

    @staticmethod
    def setPolygonOffsetOverride(state, node, override):
        r"""setPolygonOffsetOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setPolygonOffsetOverride(state, node, override)

    @staticmethod
    def setShapeHintsOverride(state, node, override):
        r"""setShapeHintsOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setShapeHintsOverride(state, node, override)

    @staticmethod
    def setShininessOverride(state, node, override):
        r"""setShininessOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setShininessOverride(state, node, override)

    @staticmethod
    def setSpecularColorOverride(state, node, override):
        r"""setSpecularColorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setSpecularColorOverride(state, node, override)

    @staticmethod
    def setTransparencyOverride(state, node, override):
        r"""setTransparencyOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setTransparencyOverride(state, node, override)

    @staticmethod
    def setTransparencyTypeOverride(state, node, override):
        r"""setTransparencyTypeOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setTransparencyTypeOverride(state, node, override)

    @staticmethod
    def setNormalVectorOverride(state, node, override):
        r"""setNormalVectorOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setNormalVectorOverride(state, node, override)

    @staticmethod
    def setNormalBindingOverride(state, node, override):
        r"""setNormalBindingOverride(SoState state, SoNode node, SbBool const override)"""
        return _coin.SoOverrideElement_setNormalBindingOverride(state, node, override)

    def output(self, file):
        r"""output(SoOverrideElement self, FILE * file)"""
        return _coin.SoOverrideElement_output(self, file)

# Register SoOverrideElement in _coin:
_coin.SoOverrideElement_swigregister(SoOverrideElement)
class SoPickRayElement(SoElement):
    r"""Proxy of C++ SoPickRayElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPickRayElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoPickRayElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoPickRayElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPickRayElement_initClass()

    def init(self, state):
        r"""init(SoPickRayElement self, SoState state)"""
        return _coin.SoPickRayElement_init(self, state)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoPickRayElement self) -> SoElement"""
        return _coin.SoPickRayElement_copyMatchInfo(self)

    @staticmethod
    def set(state, volume):
        r"""set(SoState state, SbViewVolume volume)"""
        return _coin.SoPickRayElement_set(state, volume)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbViewVolume"""
        return _coin.SoPickRayElement_get(state)

# Register SoPickRayElement in _coin:
_coin.SoPickRayElement_swigregister(SoPickRayElement)
class SoGLCoordinateElement(SoCoordinateElement):
    r"""Proxy of C++ SoGLCoordinateElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLCoordinateElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLCoordinateElement_initClass()

    def getPtr3(self):
        r"""getPtr3(SoGLCoordinateElement self) -> SbVec3f"""
        return _coin.SoGLCoordinateElement_getPtr3(self)

    def getPtr4(self):
        r"""getPtr4(SoGLCoordinateElement self) -> SbVec4f"""
        return _coin.SoGLCoordinateElement_getPtr4(self)

    def send(self, index):
        r"""send(SoGLCoordinateElement self, int const index)"""
        return _coin.SoGLCoordinateElement_send(self, index)

# Register SoGLCoordinateElement in _coin:
_coin.SoGLCoordinateElement_swigregister(SoGLCoordinateElement)
class SoEnvironmentElement(SoReplacedElement):
    r"""Proxy of C++ SoEnvironmentElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEnvironmentElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoEnvironmentElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoEnvironmentElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoEnvironmentElement_initClass()
    NONE = _coin.SoEnvironmentElement_NONE
    
    HAZE = _coin.SoEnvironmentElement_HAZE
    
    FOG = _coin.SoEnvironmentElement_FOG
    
    SMOKE = _coin.SoEnvironmentElement_SMOKE
    

    def init(self, state):
        r"""init(SoEnvironmentElement self, SoState state)"""
        return _coin.SoEnvironmentElement_init(self, state)

    @staticmethod
    def set(state, node, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart=0.0):
        r"""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)"""
        return _coin.SoEnvironmentElement_set(state, node, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart)

    @staticmethod
    def get(state, ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogStart):
        r"""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)

    @staticmethod
    def getAmbientIntensity(state):
        r"""getAmbientIntensity(SoState state) -> float"""
        return _coin.SoEnvironmentElement_getAmbientIntensity(state)

    @staticmethod
    def getFogVisibility(state):
        r"""getFogVisibility(SoState state) -> float"""
        return _coin.SoEnvironmentElement_getFogVisibility(state)

    @staticmethod
    def getLightAttenuation(state):
        r"""getLightAttenuation(SoState state) -> SbVec3f"""
        return _coin.SoEnvironmentElement_getLightAttenuation(state)

    @staticmethod
    def getAmbientColor(state):
        r"""getAmbientColor(SoState state) -> SbColor"""
        return _coin.SoEnvironmentElement_getAmbientColor(state)

    @staticmethod
    def getFogColor(state):
        r"""getFogColor(SoState state) -> SbColor"""
        return _coin.SoEnvironmentElement_getFogColor(state)

    @staticmethod
    def getFogType(state):
        r"""getFogType(SoState state) -> int32_t"""
        return _coin.SoEnvironmentElement_getFogType(state)

    @staticmethod
    def getDefault(ambientIntensity, ambientColor, attenuation, fogType, fogColor, fogVisibility, fogNear):
        r"""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)

    def output(self, file):
        r"""output(SoEnvironmentElement self, FILE * file)"""
        return _coin.SoEnvironmentElement_output(self, file)

# Register SoEnvironmentElement in _coin:
_coin.SoEnvironmentElement_swigregister(SoEnvironmentElement)
class SoGLEnvironmentElement(SoEnvironmentElement):
    r"""Proxy of C++ SoGLEnvironmentElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLEnvironmentElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLEnvironmentElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLEnvironmentElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLEnvironmentElement_initClass()

    def init(self, state):
        r"""init(SoGLEnvironmentElement self, SoState state)"""
        return _coin.SoGLEnvironmentElement_init(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLEnvironmentElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLEnvironmentElement_pop(self, state, prevTopElement)

# Register SoGLEnvironmentElement in _coin:
_coin.SoGLEnvironmentElement_swigregister(SoGLEnvironmentElement)
class SoFontNameElement(SoReplacedElement):
    r"""Proxy of C++ SoFontNameElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFontNameElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoFontNameElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoFontNameElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFontNameElement_initClass()

    def init(self, state):
        r"""init(SoFontNameElement self, SoState state)"""
        return _coin.SoFontNameElement_init(self, state)

    @staticmethod
    def set(state, node, fontName):
        r"""set(SoState state, SoNode node, SbName fontName)"""
        return _coin.SoFontNameElement_set(state, node, fontName)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbName"""
        return _coin.SoFontNameElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SbName"""
        return _coin.SoFontNameElement_getDefault()

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoFontNameElement self) -> SoElement"""
        return _coin.SoFontNameElement_copyMatchInfo(self)

    def output(self, file):
        r"""output(SoFontNameElement self, FILE * file)"""
        return _coin.SoFontNameElement_output(self, file)

# Register SoFontNameElement in _coin:
_coin.SoFontNameElement_swigregister(SoFontNameElement)
class SoLightAttenuationElement(SoReplacedElement):
    r"""Proxy of C++ SoLightAttenuationElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightAttenuationElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoLightAttenuationElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoLightAttenuationElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLightAttenuationElement_initClass()

    def init(self, state):
        r"""init(SoLightAttenuationElement self, SoState state)"""
        return _coin.SoLightAttenuationElement_init(self, state)

    @staticmethod
    def set(state, node, lightAttenuation):
        r"""set(SoState state, SoNode node, SbVec3f lightAttenuation)"""
        return _coin.SoLightAttenuationElement_set(state, node, lightAttenuation)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbVec3f"""
        return _coin.SoLightAttenuationElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SbVec3f"""
        return _coin.SoLightAttenuationElement_getDefault()

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoLightAttenuationElement self) -> SoElement"""
        return _coin.SoLightAttenuationElement_copyMatchInfo(self)

    def output(self, file):
        r"""output(SoLightAttenuationElement self, FILE * file)"""
        return _coin.SoLightAttenuationElement_output(self, file)

# Register SoLightAttenuationElement in _coin:
_coin.SoLightAttenuationElement_swigregister(SoLightAttenuationElement)
class SoPolygonOffsetElement(SoReplacedElement):
    r"""Proxy of C++ SoPolygonOffsetElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPolygonOffsetElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoPolygonOffsetElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoPolygonOffsetElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPolygonOffsetElement_initClass()
    FILLED = _coin.SoPolygonOffsetElement_FILLED
    
    LINES = _coin.SoPolygonOffsetElement_LINES
    
    POINTS = _coin.SoPolygonOffsetElement_POINTS
    

    def init(self, state):
        r"""init(SoPolygonOffsetElement self, SoState state)"""
        return _coin.SoPolygonOffsetElement_init(self, state)

    @staticmethod
    def set(state, node, factor, units, styles, on):
        r"""set(SoState state, SoNode node, float factor, float units, SoPolygonOffsetElement::Style styles, SbBool on)"""
        return _coin.SoPolygonOffsetElement_set(state, node, factor, units, styles, on)

    @staticmethod
    def get(state, factor, units, styles, on):
        r"""get(SoState state, float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
        return _coin.SoPolygonOffsetElement_get(state, factor, units, styles, on)

    @staticmethod
    def getDefault(factor, units, styles, on):
        r"""getDefault(float & factor, float & units, SoPolygonOffsetElement::Style & styles, SbBool & on)"""
        return _coin.SoPolygonOffsetElement_getDefault(factor, units, styles, on)

# Register SoPolygonOffsetElement in _coin:
_coin.SoPolygonOffsetElement_swigregister(SoPolygonOffsetElement)
class SoGLPolygonOffsetElement(SoPolygonOffsetElement):
    r"""Proxy of C++ SoGLPolygonOffsetElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLPolygonOffsetElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLPolygonOffsetElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLPolygonOffsetElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLPolygonOffsetElement_initClass()

    def init(self, state):
        r"""init(SoGLPolygonOffsetElement self, SoState state)"""
        return _coin.SoGLPolygonOffsetElement_init(self, state)

    def push(self, state):
        r"""push(SoGLPolygonOffsetElement self, SoState state)"""
        return _coin.SoGLPolygonOffsetElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLPolygonOffsetElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLPolygonOffsetElement_pop(self, state, prevTopElement)

# Register SoGLPolygonOffsetElement in _coin:
_coin.SoGLPolygonOffsetElement_swigregister(SoGLPolygonOffsetElement)
class SoProjectionMatrixElement(SoReplacedElement):
    r"""Proxy of C++ SoProjectionMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProjectionMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoProjectionMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoProjectionMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoProjectionMatrixElement_initClass()

    def init(self, state):
        r"""init(SoProjectionMatrixElement self, SoState state)"""
        return _coin.SoProjectionMatrixElement_init(self, state)

    @staticmethod
    def set(state, node):
        r"""set(SoState state, SoNode node)"""
        return _coin.SoProjectionMatrixElement_set(state, node)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoProjectionMatrixElement_get(state)

# Register SoProjectionMatrixElement in _coin:
_coin.SoProjectionMatrixElement_swigregister(SoProjectionMatrixElement)
class SoGLProjectionMatrixElement(SoProjectionMatrixElement):
    r"""Proxy of C++ SoGLProjectionMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLProjectionMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLProjectionMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLProjectionMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLProjectionMatrixElement_initClass()

    def pop(self, state, prevTopElement):
        r"""pop(SoGLProjectionMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLProjectionMatrixElement_pop(self, state, prevTopElement)

# Register SoGLProjectionMatrixElement in _coin:
_coin.SoGLProjectionMatrixElement_swigregister(SoGLProjectionMatrixElement)
class SoProfileCoordinateElement(SoReplacedElement):
    r"""Proxy of C++ SoProfileCoordinateElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoProfileCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoProfileCoordinateElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoProfileCoordinateElement_initClass()

    def init(self, state):
        r"""init(SoProfileCoordinateElement self, SoState state)"""
        return _coin.SoProfileCoordinateElement_init(self, state)

    @staticmethod
    def set2(state, node, numCoords, coords):
        r"""set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)"""
        return _coin.SoProfileCoordinateElement_set2(state, node, numCoords, coords)

    @staticmethod
    def set3(state, node, numCoords, coords):
        r"""set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoProfileCoordinateElement_set3(state, node, numCoords, coords)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoProfileCoordinateElement"""
        return _coin.SoProfileCoordinateElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoProfileCoordinateElement self) -> int32_t"""
        return _coin.SoProfileCoordinateElement_getNum(self)

    def get2(self, index):
        r"""get2(SoProfileCoordinateElement self, int const index) -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_get2(self, index)

    def get3(self, index):
        r"""get3(SoProfileCoordinateElement self, int const index) -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_get3(self, index)

    def is2D(self):
        r"""is2D(SoProfileCoordinateElement self) -> SbBool"""
        return _coin.SoProfileCoordinateElement_is2D(self)

    @staticmethod
    def getDefault2():
        r"""getDefault2() -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_getDefault2()

    @staticmethod
    def getDefault3():
        r"""getDefault3() -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_getDefault3()

    def getArrayPtr2(self):
        r"""getArrayPtr2(SoProfileCoordinateElement self) -> SbVec2f"""
        return _coin.SoProfileCoordinateElement_getArrayPtr2(self)

    def getArrayPtr3(self):
        r"""getArrayPtr3(SoProfileCoordinateElement self) -> SbVec3f"""
        return _coin.SoProfileCoordinateElement_getArrayPtr3(self)

# Register SoProfileCoordinateElement in _coin:
_coin.SoProfileCoordinateElement_swigregister(SoProfileCoordinateElement)
class SoGLTextureImageElement(SoTextureImageElement):
    r"""Proxy of C++ SoGLTextureImageElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLTextureImageElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLTextureImageElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLTextureImageElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLTextureImageElement_initClass()

    def init(self, state):
        r"""init(SoGLTextureImageElement self, SoState state)"""
        return _coin.SoGLTextureImageElement_init(self, state)

    def push(self, state):
        r"""push(SoGLTextureImageElement self, SoState state)"""
        return _coin.SoGLTextureImageElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLTextureImageElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLTextureImageElement_pop(self, state, prevTopElement)

    @staticmethod
    def set(state, node, image, model, blendColor):
        r"""set(SoState state, SoNode node, SoGLImage image, SoTextureImageElement::Model const model, SbColor blendColor)"""
        return _coin.SoGLTextureImageElement_set(state, node, image, model, blendColor)

    @staticmethod
    def get(state, model, blendcolor):
        r"""get(SoState state, SoTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage"""
        return _coin.SoGLTextureImageElement_get(state, model, blendcolor)

    @staticmethod
    def getMaxGLTextureSize():
        r"""getMaxGLTextureSize() -> int32_t"""
        return _coin.SoGLTextureImageElement_getMaxGLTextureSize()

    def isTextureSizeLegal(self, xsize, ysize, zsize, bytespertexel):
        r"""isTextureSizeLegal(SoGLTextureImageElement self, int xsize, int ysize, int zsize, int bytespertexel) -> SbBool"""
        return _coin.SoGLTextureImageElement_isTextureSizeLegal(self, xsize, ysize, zsize, bytespertexel)

    @staticmethod
    def hasTransparency(state):
        r"""hasTransparency(SoState state) -> SbBool"""
        return _coin.SoGLTextureImageElement_hasTransparency(state)

# Register SoGLTextureImageElement in _coin:
_coin.SoGLTextureImageElement_swigregister(SoGLTextureImageElement)
class SoViewingMatrixElement(SoReplacedElement):
    r"""Proxy of C++ SoViewingMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoViewingMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoViewingMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoViewingMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoViewingMatrixElement_initClass()

    def init(self, state):
        r"""init(SoViewingMatrixElement self, SoState state)"""
        return _coin.SoViewingMatrixElement_init(self, state)

    @staticmethod
    def set(state, node, ViewingMatrix):
        r"""set(SoState state, SoNode node, SbMatrix ViewingMatrix)"""
        return _coin.SoViewingMatrixElement_set(state, node, ViewingMatrix)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbMatrix"""
        return _coin.SoViewingMatrixElement_get(state)

# Register SoViewingMatrixElement in _coin:
_coin.SoViewingMatrixElement_swigregister(SoViewingMatrixElement)
class SoGLViewingMatrixElement(SoViewingMatrixElement):
    r"""Proxy of C++ SoGLViewingMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLViewingMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLViewingMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLViewingMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLViewingMatrixElement_initClass()

    def init(self, state):
        r"""init(SoGLViewingMatrixElement self, SoState state)"""
        return _coin.SoGLViewingMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoGLViewingMatrixElement self, SoState state)"""
        return _coin.SoGLViewingMatrixElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLViewingMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLViewingMatrixElement_pop(self, state, prevTopElement)

    @staticmethod
    def getNodeId(state):
        r"""getNodeId(SoState state) -> uint32_t"""
        return _coin.SoGLViewingMatrixElement_getNodeId(state)

    @staticmethod
    def getResetMatrix(state):
        r"""getResetMatrix(SoState state) -> SbMatrix"""
        return _coin.SoGLViewingMatrixElement_getResetMatrix(state)

# Register SoGLViewingMatrixElement in _coin:
_coin.SoGLViewingMatrixElement_swigregister(SoGLViewingMatrixElement)
class SoViewVolumeElement(SoReplacedElement):
    r"""Proxy of C++ SoViewVolumeElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoViewVolumeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoViewVolumeElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoViewVolumeElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoViewVolumeElement_initClass()

    def init(self, state):
        r"""init(SoViewVolumeElement self, SoState state)"""
        return _coin.SoViewVolumeElement_init(self, state)

    @staticmethod
    def set(state, node, viewVolume):
        r"""set(SoState state, SoNode node, SbViewVolume viewVolume)"""
        return _coin.SoViewVolumeElement_set(state, node, viewVolume)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbViewVolume"""
        return _coin.SoViewVolumeElement_get(state)

# Register SoViewVolumeElement in _coin:
_coin.SoViewVolumeElement_swigregister(SoViewVolumeElement)
class SoGLShapeHintsElement(SoShapeHintsElement):
    r"""Proxy of C++ SoGLShapeHintsElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLShapeHintsElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLShapeHintsElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLShapeHintsElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLShapeHintsElement_initClass()

    def init(self, state):
        r"""init(SoGLShapeHintsElement self, SoState state)"""
        return _coin.SoGLShapeHintsElement_init(self, state)

    def push(self, state):
        r"""push(SoGLShapeHintsElement self, SoState state)"""
        return _coin.SoGLShapeHintsElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLShapeHintsElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLShapeHintsElement_pop(self, state, prevTopElement)

    @staticmethod
    def forceSend(*args):
        r"""
        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)

# Register SoGLShapeHintsElement in _coin:
_coin.SoGLShapeHintsElement_swigregister(SoGLShapeHintsElement)
class SoShapeStyleElement(SoElement):
    r"""Proxy of C++ SoShapeStyleElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShapeStyleElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoShapeStyleElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoShapeStyleElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShapeStyleElement_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):
        r"""init(SoShapeStyleElement self, SoState state)"""
        return _coin.SoShapeStyleElement_init(self, state)

    def push(self, state):
        r"""push(SoShapeStyleElement self, SoState state)"""
        return _coin.SoShapeStyleElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoShapeStyleElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoShapeStyleElement_pop(self, state, prevTopElement)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoShapeStyleElement self) -> SoElement"""
        return _coin.SoShapeStyleElement_copyMatchInfo(self)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoShapeStyleElement"""
        return _coin.SoShapeStyleElement_get(state)

    def getFlags(self):
        r"""getFlags(SoShapeStyleElement self) -> unsigned int"""
        return _coin.SoShapeStyleElement_getFlags(self)

    def mightNotRender(self):
        r"""mightNotRender(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_mightNotRender(self)

    def needNormals(self):
        r"""needNormals(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_needNormals(self)

    def needTexCoords(self):
        r"""needTexCoords(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_needTexCoords(self)

    def getRenderCaseMask(self):
        r"""getRenderCaseMask(SoShapeStyleElement self) -> int"""
        return _coin.SoShapeStyleElement_getRenderCaseMask(self)

    @staticmethod
    def setDrawStyle(state, value):
        r"""setDrawStyle(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setDrawStyle(state, value)

    @staticmethod
    def setComplexityType(state, value):
        r"""setComplexityType(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setComplexityType(state, value)

    @staticmethod
    def setTransparencyType(state, value):
        r"""setTransparencyType(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setTransparencyType(state, value)

    @staticmethod
    def setTextureEnabled(state, value):
        r"""setTextureEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTextureEnabled(state, value)

    @staticmethod
    def setTexture3Enabled(state, value):
        r"""setTexture3Enabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTexture3Enabled(state, value)

    @staticmethod
    def setTextureFunction(state, value):
        r"""setTextureFunction(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTextureFunction(state, value)

    @staticmethod
    def setLightModel(state, value):
        r"""setLightModel(SoState state, int32_t const value)"""
        return _coin.SoShapeStyleElement_setLightModel(state, value)

    @staticmethod
    def setOverrides(state, value):
        r"""setOverrides(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setOverrides(state, value)

    @staticmethod
    def isScreenDoor(state):
        r"""isScreenDoor(SoState state) -> SbBool"""
        return _coin.SoShapeStyleElement_isScreenDoor(state)

    @staticmethod
    def getTransparencyType(state):
        r"""getTransparencyType(SoState state) -> int"""
        return _coin.SoShapeStyleElement_getTransparencyType(state)

    def isTextureFunction(self):
        r"""isTextureFunction(SoShapeStyleElement self) -> SbBool"""
        return _coin.SoShapeStyleElement_isTextureFunction(self)

    @staticmethod
    def setBumpmapEnabled(state, value):
        r"""setBumpmapEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setBumpmapEnabled(state, value)

    @staticmethod
    def setBigImageEnabled(state, value):
        r"""setBigImageEnabled(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setBigImageEnabled(state, value)

    @staticmethod
    def setVertexArrayRendering(state, value):
        r"""setVertexArrayRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setVertexArrayRendering(state, value)

    @staticmethod
    def setTransparentMaterial(state, value):
        r"""setTransparentMaterial(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTransparentMaterial(state, value)

    @staticmethod
    def setTransparentTexture(state, value):
        r"""setTransparentTexture(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setTransparentTexture(state, value)

    @staticmethod
    def setShadowMapRendering(state, value):
        r"""setShadowMapRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setShadowMapRendering(state, value)

    @staticmethod
    def setShadowsRendering(state, value):
        r"""setShadowsRendering(SoState state, SbBool const value)"""
        return _coin.SoShapeStyleElement_setShadowsRendering(state, value)

# Register SoShapeStyleElement in _coin:
_coin.SoShapeStyleElement_swigregister(SoShapeStyleElement)
class SoViewportRegionElement(SoElement):
    r"""Proxy of C++ SoViewportRegionElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoViewportRegionElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoViewportRegionElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoViewportRegionElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoViewportRegionElement_initClass()

    def init(self, state):
        r"""init(SoViewportRegionElement self, SoState state)"""
        return _coin.SoViewportRegionElement_init(self, state)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoViewportRegionElement self) -> SoElement"""
        return _coin.SoViewportRegionElement_copyMatchInfo(self)

    @staticmethod
    def set(state, viewportRegion):
        r"""set(SoState state, SbViewportRegion viewportRegion)"""
        return _coin.SoViewportRegionElement_set(state, viewportRegion)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbViewportRegion"""
        return _coin.SoViewportRegionElement_get(state)

    def output(self, file):
        r"""output(SoViewportRegionElement self, FILE * file)"""
        return _coin.SoViewportRegionElement_output(self, file)

# Register SoViewportRegionElement in _coin:
_coin.SoViewportRegionElement_swigregister(SoViewportRegionElement)
class SoGLViewportRegionElement(SoViewportRegionElement):
    r"""Proxy of C++ SoGLViewportRegionElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLViewportRegionElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLViewportRegionElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLViewportRegionElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLViewportRegionElement_initClass()

    def init(self, state):
        r"""init(SoGLViewportRegionElement self, SoState state)"""
        return _coin.SoGLViewportRegionElement_init(self, state)

    def push(self, state):
        r"""push(SoGLViewportRegionElement self, SoState state)"""
        return _coin.SoGLViewportRegionElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLViewportRegionElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLViewportRegionElement_pop(self, state, prevTopElement)

# Register SoGLViewportRegionElement in _coin:
_coin.SoGLViewportRegionElement_swigregister(SoGLViewportRegionElement)
class SoWindowElement(SoElement):
    r"""Proxy of C++ SoWindowElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWindowElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoWindowElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoWindowElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoWindowElement_initClass()

    def init(self, state):
        r"""init(SoWindowElement self, SoState state)"""
        return _coin.SoWindowElement_init(self, state)

    def push(self, state):
        r"""push(SoWindowElement self, SoState state)"""
        return _coin.SoWindowElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoWindowElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoWindowElement_pop(self, state, prevTopElement)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoWindowElement self) -> SoElement"""
        return _coin.SoWindowElement_copyMatchInfo(self)

    @staticmethod
    def set(state, window, context, display, action):
        r"""set(SoState state, void * window, void * context, void * display, SoGLRenderAction action)"""
        return _coin.SoWindowElement_set(state, window, context, display, action)

    @staticmethod
    def get(state, window, context, display, action):
        r"""get(SoState state, void *& window, void *& context, void *& display, SoGLRenderAction *& action)"""
        return _coin.SoWindowElement_get(state, window, context, display, action)

# Register SoWindowElement in _coin:
_coin.SoWindowElement_swigregister(SoWindowElement)
class SoGLCacheContextElement(SoElement):
    r"""Proxy of C++ SoGLCacheContextElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLCacheContextElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLCacheContextElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLCacheContextElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLCacheContextElement_initClass()

    def init(self, state):
        r"""init(SoGLCacheContextElement self, SoState state)"""
        return _coin.SoGLCacheContextElement_init(self, state)

    def matches(self, elt):
        r"""matches(SoGLCacheContextElement self, SoElement elt) -> SbBool"""
        return _coin.SoGLCacheContextElement_matches(self, elt)

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoGLCacheContextElement self) -> SoElement"""
        return _coin.SoGLCacheContextElement_copyMatchInfo(self)

    @staticmethod
    def set(state, context, twopasstransparency, remoterendering):
        r"""set(SoState state, int context, SbBool twopasstransparency, SbBool remoterendering)"""
        return _coin.SoGLCacheContextElement_set(state, context, twopasstransparency, remoterendering)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_get(state)

    @staticmethod
    def getExtID(str):
        r"""getExtID(char const * str) -> int"""
        return _coin.SoGLCacheContextElement_getExtID(str)

    @staticmethod
    def getOpenGLVersion(state, major, minor):
        r"""getOpenGLVersion(SoState state, int & major, int & minor)"""
        return _coin.SoGLCacheContextElement_getOpenGLVersion(state, major, minor)

    @staticmethod
    def extSupported(state, extid):
        r"""extSupported(SoState state, int extid) -> SbBool"""
        return _coin.SoGLCacheContextElement_extSupported(state, extid)

    @staticmethod
    def areMipMapsFast(state):
        r"""areMipMapsFast(SoState state) -> SbBool"""
        return _coin.SoGLCacheContextElement_areMipMapsFast(state)
    DO_AUTO_CACHE = _coin.SoGLCacheContextElement_DO_AUTO_CACHE
    
    DONT_AUTO_CACHE = _coin.SoGLCacheContextElement_DONT_AUTO_CACHE
    

    @staticmethod
    def shouldAutoCache(state, bits):
        r"""shouldAutoCache(SoState state, int bits)"""
        return _coin.SoGLCacheContextElement_shouldAutoCache(state, bits)

    @staticmethod
    def setAutoCacheBits(state, bits):
        r"""setAutoCacheBits(SoState state, int bits)"""
        return _coin.SoGLCacheContextElement_setAutoCacheBits(state, bits)

    @staticmethod
    def resetAutoCacheBits(state):
        r"""resetAutoCacheBits(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_resetAutoCacheBits(state)

    @staticmethod
    def getIsRemoteRendering(state):
        r"""getIsRemoteRendering(SoState state) -> SbBool"""
        return _coin.SoGLCacheContextElement_getIsRemoteRendering(state)

    @staticmethod
    def getUniqueCacheContext():
        r"""getUniqueCacheContext() -> uint32_t"""
        return _coin.SoGLCacheContextElement_getUniqueCacheContext()

    @staticmethod
    def scheduleDeleteCallback(contextid, cb, closure):
        r"""scheduleDeleteCallback(uint32_t const contextid, SoScheduleDeleteCB * cb, void * closure)"""
        return _coin.SoGLCacheContextElement_scheduleDeleteCallback(contextid, cb, closure)

    @staticmethod
    def incNumShapes(state):
        r"""incNumShapes(SoState state)"""
        return _coin.SoGLCacheContextElement_incNumShapes(state)

    @staticmethod
    def getNumShapes(state):
        r"""getNumShapes(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_getNumShapes(state)

    @staticmethod
    def incNumSeparators(state):
        r"""incNumSeparators(SoState state)"""
        return _coin.SoGLCacheContextElement_incNumSeparators(state)

    @staticmethod
    def getNumSeparators(state):
        r"""getNumSeparators(SoState state) -> int"""
        return _coin.SoGLCacheContextElement_getNumSeparators(state)

# Register SoGLCacheContextElement in _coin:
_coin.SoGLCacheContextElement_swigregister(SoGLCacheContextElement)
class SoGLDisplayList(object):
    r"""Proxy of C++ SoGLDisplayList class."""

    thisown = 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):
        r"""__init__(SoGLDisplayList self, SoState state, SoGLDisplayList::Type type, int allocnum=1, SbBool mipmaptexobj=0) -> SoGLDisplayList"""
        _coin.SoGLDisplayList_swiginit(self, _coin.new_SoGLDisplayList(state, type, allocnum, mipmaptexobj))

    def ref(self):
        r"""ref(SoGLDisplayList self)"""
        return _coin.SoGLDisplayList_ref(self)

    def unref(self, state=None):
        r"""unref(SoGLDisplayList self, SoState state=None)"""
        return _coin.SoGLDisplayList_unref(self, state)

    def open(self, state, index=0):
        r"""open(SoGLDisplayList self, SoState state, int index=0)"""
        return _coin.SoGLDisplayList_open(self, state, index)

    def close(self, state):
        r"""close(SoGLDisplayList self, SoState state)"""
        return _coin.SoGLDisplayList_close(self, state)

    def call(self, state, index=0):
        r"""call(SoGLDisplayList self, SoState state, int index=0)"""
        return _coin.SoGLDisplayList_call(self, state, index)

    def addDependency(self, state):
        r"""addDependency(SoGLDisplayList self, SoState state)"""
        return _coin.SoGLDisplayList_addDependency(self, state)

    def isMipMapTextureObject(self):
        r"""isMipMapTextureObject(SoGLDisplayList self) -> SbBool"""
        return _coin.SoGLDisplayList_isMipMapTextureObject(self)

    def getType(self):
        r"""getType(SoGLDisplayList self) -> SoGLDisplayList::Type"""
        return _coin.SoGLDisplayList_getType(self)

    def getNumAllocated(self):
        r"""getNumAllocated(SoGLDisplayList self) -> int"""
        return _coin.SoGLDisplayList_getNumAllocated(self)

    def getFirstIndex(self):
        r"""getFirstIndex(SoGLDisplayList self) -> unsigned int"""
        return _coin.SoGLDisplayList_getFirstIndex(self)

    def getContext(self):
        r"""getContext(SoGLDisplayList self) -> int"""
        return _coin.SoGLDisplayList_getContext(self)

    def setTextureTarget(self, target):
        r"""setTextureTarget(SoGLDisplayList self, int target)"""
        return _coin.SoGLDisplayList_setTextureTarget(self, target)

    def getTextureTarget(self):
        r"""getTextureTarget(SoGLDisplayList self) -> int"""
        return _coin.SoGLDisplayList_getTextureTarget(self)

# Register SoGLDisplayList in _coin:
_coin.SoGLDisplayList_swigregister(SoGLDisplayList)
class SoGLColorIndexElement(SoReplacedElement):
    r"""Proxy of C++ SoGLColorIndexElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLColorIndexElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLColorIndexElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLColorIndexElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLColorIndexElement_initClass()

    @staticmethod
    def isColorIndexMode(state):
        r"""isColorIndexMode(SoState state) -> SbBool"""
        return _coin.SoGLColorIndexElement_isColorIndexMode(state)

    def init(self, state):
        r"""init(SoGLColorIndexElement self, SoState state)"""
        return _coin.SoGLColorIndexElement_init(self, state)

    @staticmethod
    def set(state, node, numindices, indices):
        r"""set(SoState state, SoNode node, int32_t const numindices, int32_t const *const indices)"""
        return _coin.SoGLColorIndexElement_set(state, node, numindices, indices)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoGLColorIndexElement"""
        return _coin.SoGLColorIndexElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoGLColorIndexElement self) -> int32_t"""
        return _coin.SoGLColorIndexElement_getNum(self)

    def get(self, index):
        r"""get(SoGLColorIndexElement self, int const index) -> int32_t"""
        return _coin.SoGLColorIndexElement_get(self, index)

    @staticmethod
    def getDefault():
        r"""getDefault() -> int32_t"""
        return _coin.SoGLColorIndexElement_getDefault()

# Register SoGLColorIndexElement in _coin:
_coin.SoGLColorIndexElement_swigregister(SoGLColorIndexElement)
class SoListenerPositionElement(SoReplacedElement):
    r"""Proxy of C++ SoListenerPositionElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListenerPositionElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoListenerPositionElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoListenerPositionElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoListenerPositionElement_initClass()

    def init(self, state):
        r"""init(SoListenerPositionElement self, SoState state)"""
        return _coin.SoListenerPositionElement_init(self, state)

    @staticmethod
    def set(state, node, position, setbylistener):
        r"""set(SoState state, SoNode node, SbVec3f position, SbBool setbylistener)"""
        return _coin.SoListenerPositionElement_set(state, node, position, setbylistener)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbVec3f"""
        return _coin.SoListenerPositionElement_get(state)

    @staticmethod
    def isSetByListener(state):
        r"""isSetByListener(SoState state) -> SbBool"""
        return _coin.SoListenerPositionElement_isSetByListener(state)

    def output(self, file):
        r"""output(SoListenerPositionElement self, FILE * file)"""
        return _coin.SoListenerPositionElement_output(self, file)

# Register SoListenerPositionElement in _coin:
_coin.SoListenerPositionElement_swigregister(SoListenerPositionElement)
class SoListenerOrientationElement(SoReplacedElement):
    r"""Proxy of C++ SoListenerOrientationElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListenerOrientationElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoListenerOrientationElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoListenerOrientationElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoListenerOrientationElement_initClass()

    def init(self, state):
        r"""init(SoListenerOrientationElement self, SoState state)"""
        return _coin.SoListenerOrientationElement_init(self, state)

    @staticmethod
    def set(state, node, orientation, setbylistener):
        r"""set(SoState state, SoNode node, SbRotation orientation, SbBool setbylistener)"""
        return _coin.SoListenerOrientationElement_set(state, node, orientation, setbylistener)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SbRotation"""
        return _coin.SoListenerOrientationElement_get(state)

    @staticmethod
    def isSetByListener(state):
        r"""isSetByListener(SoState state) -> SbBool"""
        return _coin.SoListenerOrientationElement_isSetByListener(state)

    def output(self, file):
        r"""output(SoListenerOrientationElement self, FILE * file)"""
        return _coin.SoListenerOrientationElement_output(self, file)

# Register SoListenerOrientationElement in _coin:
_coin.SoListenerOrientationElement_swigregister(SoListenerOrientationElement)
class SoListenerDopplerElement(SoReplacedElement):
    r"""Proxy of C++ SoListenerDopplerElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListenerDopplerElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoListenerDopplerElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoListenerDopplerElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoListenerDopplerElement_initClass()

    def init(self, state):
        r"""init(SoListenerDopplerElement self, SoState state)"""
        return _coin.SoListenerDopplerElement_init(self, state)

    @staticmethod
    def setDopplerVelocity(state, node, velocity):
        r"""setDopplerVelocity(SoState state, SoNode node, SbVec3f velocity)"""
        return _coin.SoListenerDopplerElement_setDopplerVelocity(state, node, velocity)

    @staticmethod
    def setDopplerFactor(state, node, factor):
        r"""setDopplerFactor(SoState state, SoNode node, float factor)"""
        return _coin.SoListenerDopplerElement_setDopplerFactor(state, node, factor)

    @staticmethod
    def getDopplerVelocity(state):
        r"""getDopplerVelocity(SoState state) -> SbVec3f"""
        return _coin.SoListenerDopplerElement_getDopplerVelocity(state)

    @staticmethod
    def getDopplerFactor(state):
        r"""getDopplerFactor(SoState state) -> float"""
        return _coin.SoListenerDopplerElement_getDopplerFactor(state)

    def output(self, file):
        r"""output(SoListenerDopplerElement self, FILE * file)"""
        return _coin.SoListenerDopplerElement_output(self, file)

# Register SoListenerDopplerElement in _coin:
_coin.SoListenerDopplerElement_swigregister(SoListenerDopplerElement)
class SoListenerGainElement(SoFloatElement):
    r"""Proxy of C++ SoListenerGainElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListenerGainElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoListenerGainElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoListenerGainElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoListenerGainElement_initClass()

    def init(self, state):
        r"""init(SoListenerGainElement self, SoState state)"""
        return _coin.SoListenerGainElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, float const gain)
        set(SoState state, float const gain)
        """
        return _coin.SoListenerGainElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> float"""
        return _coin.SoListenerGainElement_get(state)

# Register SoListenerGainElement in _coin:
_coin.SoListenerGainElement_swigregister(SoListenerGainElement)
class SoSoundElement(SoReplacedElement):
    r"""Proxy of C++ SoSoundElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSoundElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoSoundElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSoundElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSoundElement_initClass()

    def init(self, state):
        r"""init(SoSoundElement self, SoState state)"""
        return _coin.SoSoundElement_init(self, state)

    @staticmethod
    def set(state, node, scenegraphhassoundnode, soundnodeisplaying, ispartofactivescenegraph):
        r"""set(SoState state, SoNode node, SbBool scenegraphhassoundnode, SbBool soundnodeisplaying, SbBool ispartofactivescenegraph)"""
        return _coin.SoSoundElement_set(state, node, scenegraphhassoundnode, soundnodeisplaying, ispartofactivescenegraph)

    @staticmethod
    def setSceneGraphHasSoundNode(state, node, flag):
        r"""setSceneGraphHasSoundNode(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setSceneGraphHasSoundNode(state, node, flag)

    @staticmethod
    def sceneGraphHasSoundNode(state):
        r"""sceneGraphHasSoundNode(SoState state) -> SbBool"""
        return _coin.SoSoundElement_sceneGraphHasSoundNode(state)

    @staticmethod
    def setSoundNodeIsPlaying(state, node, flag):
        r"""setSoundNodeIsPlaying(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setSoundNodeIsPlaying(state, node, flag)

    @staticmethod
    def soundNodeIsPlaying(state):
        r"""soundNodeIsPlaying(SoState state) -> SbBool"""
        return _coin.SoSoundElement_soundNodeIsPlaying(state)

    @staticmethod
    def setIsPartOfActiveSceneGraph(state, node, flag):
        r"""setIsPartOfActiveSceneGraph(SoState state, SoNode node, SbBool flag) -> SbBool"""
        return _coin.SoSoundElement_setIsPartOfActiveSceneGraph(state, node, flag)

    @staticmethod
    def isPartOfActiveSceneGraph(state):
        r"""isPartOfActiveSceneGraph(SoState state) -> SbBool"""
        return _coin.SoSoundElement_isPartOfActiveSceneGraph(state)

    def push(self, state):
        r"""push(SoSoundElement self, SoState state)"""
        return _coin.SoSoundElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoSoundElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoSoundElement_pop(self, state, prevTopElement)

    def output(self, file):
        r"""output(SoSoundElement self, FILE * file)"""
        return _coin.SoSoundElement_output(self, file)

# Register SoSoundElement in _coin:
_coin.SoSoundElement_swigregister(SoSoundElement)
class SoGLVBOElement(SoElement):
    r"""Proxy of C++ SoGLVBOElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLVBOElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLVBOElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLVBOElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLVBOElement_initClass()

    @staticmethod
    def shouldCreateVBO(state, numdata):
        r"""shouldCreateVBO(SoState state, int const numdata) -> SbBool"""
        return _coin.SoGLVBOElement_shouldCreateVBO(state, numdata)

    @staticmethod
    def setVertexVBO(state, vbo):
        r"""setVertexVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setVertexVBO(state, vbo)

    @staticmethod
    def setNormalVBO(state, vbo):
        r"""setNormalVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setNormalVBO(state, vbo)

    @staticmethod
    def setColorVBO(state, vbo):
        r"""setColorVBO(SoState state, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setColorVBO(state, vbo)

    @staticmethod
    def setTexCoordVBO(state, unit, vbo):
        r"""setTexCoordVBO(SoState state, int const unit, SoVBO * vbo)"""
        return _coin.SoGLVBOElement_setTexCoordVBO(state, unit, vbo)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoGLVBOElement"""
        return _coin.SoGLVBOElement_getInstance(state)

    def init(self, state):
        r"""init(SoGLVBOElement self, SoState state)"""
        return _coin.SoGLVBOElement_init(self, state)

    def push(self, state):
        r"""push(SoGLVBOElement self, SoState state)"""
        return _coin.SoGLVBOElement_push(self, state)

    def pop(self, state, prevtopelement):
        r"""pop(SoGLVBOElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoGLVBOElement_pop(self, state, prevtopelement)

    def matches(self, elt):
        r"""matches(SoGLVBOElement self, SoElement elt) -> SbBool"""
        return _coin.SoGLVBOElement_matches(self, elt)

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoGLVBOElement self) -> SoElement"""
        return _coin.SoGLVBOElement_copyMatchInfo(self)

    def getVertexVBO(self):
        r"""getVertexVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getVertexVBO(self)

    def getNormalVBO(self):
        r"""getNormalVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getNormalVBO(self)

    def getColorVBO(self):
        r"""getColorVBO(SoGLVBOElement self) -> SoVBO *"""
        return _coin.SoGLVBOElement_getColorVBO(self)

    def getNumTexCoordVBO(self):
        r"""getNumTexCoordVBO(SoGLVBOElement self) -> int"""
        return _coin.SoGLVBOElement_getNumTexCoordVBO(self)

    def getTexCoordVBO(self, idx):
        r"""getTexCoordVBO(SoGLVBOElement self, int const idx) -> SoVBO *"""
        return _coin.SoGLVBOElement_getTexCoordVBO(self, idx)

# Register SoGLVBOElement in _coin:
_coin.SoGLVBOElement_swigregister(SoGLVBOElement)
class SoDepthBufferElement(SoElement):
    r"""Proxy of C++ SoDepthBufferElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDepthBufferElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoDepthBufferElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDepthBufferElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDepthBufferElement_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
    

    @staticmethod
    def set(state, test, write, function, range):
        r"""set(SoState state, SbBool test, SbBool write, SoDepthBufferElement::DepthWriteFunction function, SbVec2f range)"""
        return _coin.SoDepthBufferElement_set(state, test, write, function, range)

    @staticmethod
    def get(state, test_out, write_out, function_out, range_out):
        r"""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)

    @staticmethod
    def getTestEnable(state):
        r"""getTestEnable(SoState state) -> SbBool"""
        return _coin.SoDepthBufferElement_getTestEnable(state)

    @staticmethod
    def getWriteEnable(state):
        r"""getWriteEnable(SoState state) -> SbBool"""
        return _coin.SoDepthBufferElement_getWriteEnable(state)

    @staticmethod
    def getFunction(state):
        r"""getFunction(SoState state) -> SoDepthBufferElement::DepthWriteFunction"""
        return _coin.SoDepthBufferElement_getFunction(state)

    @staticmethod
    def getRange(state):
        r"""getRange(SoState state) -> SbVec2f"""
        return _coin.SoDepthBufferElement_getRange(state)

    def init(self, state):
        r"""init(SoDepthBufferElement self, SoState state)"""
        return _coin.SoDepthBufferElement_init(self, state)

    def push(self, state):
        r"""push(SoDepthBufferElement self, SoState state)"""
        return _coin.SoDepthBufferElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoDepthBufferElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoDepthBufferElement_pop(self, state, prevTopElement)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoDepthBufferElement self) -> SoElement"""
        return _coin.SoDepthBufferElement_copyMatchInfo(self)

# Register SoDepthBufferElement in _coin:
_coin.SoDepthBufferElement_swigregister(SoDepthBufferElement)
class SoGLDepthBufferElement(SoDepthBufferElement):
    r"""Proxy of C++ SoGLDepthBufferElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLDepthBufferElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLDepthBufferElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLDepthBufferElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLDepthBufferElement_initClass()

    def init(self, state):
        r"""init(SoGLDepthBufferElement self, SoState state)"""
        return _coin.SoGLDepthBufferElement_init(self, state)

    def push(self, state):
        r"""push(SoGLDepthBufferElement self, SoState state)"""
        return _coin.SoGLDepthBufferElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLDepthBufferElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLDepthBufferElement_pop(self, state, prevTopElement)

# Register SoGLDepthBufferElement in _coin:
_coin.SoGLDepthBufferElement_swigregister(SoGLDepthBufferElement)
class SoVertexAttributeElement(SoAccumulatedElement):
    r"""Proxy of C++ SoVertexAttributeElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoVertexAttributeElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVertexAttributeElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVertexAttributeElement_initClass()

    def init(self, state):
        r"""init(SoVertexAttributeElement self, SoState state)"""
        return _coin.SoVertexAttributeElement_init(self, state)

    def push(self, state):
        r"""push(SoVertexAttributeElement self, SoState state)"""
        return _coin.SoVertexAttributeElement_push(self, state)

    @staticmethod
    def add(state, attribdata):
        r"""add(SoState state, SoVertexAttributeData * attribdata)"""
        return _coin.SoVertexAttributeElement_add(state, attribdata)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoVertexAttributeElement"""
        return _coin.SoVertexAttributeElement_getInstance(state)

    def getNumAttributes(self):
        r"""getNumAttributes(SoVertexAttributeElement self) -> unsigned int"""
        return _coin.SoVertexAttributeElement_getNumAttributes(self)

    def applyToAttributes(self, func, closure):
        r"""applyToAttributes(SoVertexAttributeElement self, SoVertexAttributeElement::AttributeApplyFunc * func, void * closure)"""
        return _coin.SoVertexAttributeElement_applyToAttributes(self, func, closure)

# Register SoVertexAttributeElement in _coin:
_coin.SoVertexAttributeElement_swigregister(SoVertexAttributeElement)
class SoGLVertexAttributeElement(SoVertexAttributeElement):
    r"""Proxy of C++ SoGLVertexAttributeElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLVertexAttributeElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLVertexAttributeElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLVertexAttributeElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLVertexAttributeElement_initClass()

    def init(self, state):
        r"""init(SoGLVertexAttributeElement self, SoState state)"""
        return _coin.SoGLVertexAttributeElement_init(self, state)

    def enableVBO(self, action):
        r"""enableVBO(SoGLVertexAttributeElement self, SoGLRenderAction action)"""
        return _coin.SoGLVertexAttributeElement_enableVBO(self, action)

    def disableVBO(self, action):
        r"""disableVBO(SoGLVertexAttributeElement self, SoGLRenderAction action)"""
        return _coin.SoGLVertexAttributeElement_disableVBO(self, action)

    def send(self, index):
        r"""send(SoGLVertexAttributeElement self, int const index)"""
        return _coin.SoGLVertexAttributeElement_send(self, index)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoGLVertexAttributeElement"""
        return _coin.SoGLVertexAttributeElement_getInstance(state)

# Register SoGLVertexAttributeElement in _coin:
_coin.SoGLVertexAttributeElement_swigregister(SoGLVertexAttributeElement)
class SoVertexAttributeBindingElement(SoInt32Element):
    r"""Proxy of C++ SoVertexAttributeBindingElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeBindingElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoVertexAttributeBindingElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVertexAttributeBindingElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVertexAttributeBindingElement_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):
        r"""init(SoVertexAttributeBindingElement self, SoState state)"""
        return _coin.SoVertexAttributeBindingElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoNode node, SoVertexAttributeBindingElement::Binding const binding)
        set(SoState state, SoVertexAttributeBindingElement::Binding const binding)
        """
        return _coin.SoVertexAttributeBindingElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoVertexAttributeBindingElement::Binding"""
        return _coin.SoVertexAttributeBindingElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoVertexAttributeBindingElement::Binding"""
        return _coin.SoVertexAttributeBindingElement_getDefault()

# Register SoVertexAttributeBindingElement in _coin:
_coin.SoVertexAttributeBindingElement_swigregister(SoVertexAttributeBindingElement)
class SoSpecularColorElement(SoReplacedElement):
    r"""Proxy of C++ SoSpecularColorElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpecularColorElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoSpecularColorElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSpecularColorElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSpecularColorElement_initClass()

    def init(self, state):
        r"""init(SoSpecularColorElement self, SoState state)"""
        return _coin.SoSpecularColorElement_init(self, state)

    @staticmethod
    def set(state, node, numColors, colors):
        r"""set(SoState state, SoNode node, int32_t const numColors, SbColor colors)"""
        return _coin.SoSpecularColorElement_set(state, node, numColors, colors)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoSpecularColorElement"""
        return _coin.SoSpecularColorElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoSpecularColorElement self) -> int32_t"""
        return _coin.SoSpecularColorElement_getNum(self)

    def get(self, index):
        r"""get(SoSpecularColorElement self, int const index) -> SbColor"""
        return _coin.SoSpecularColorElement_get(self, index)

    def getArrayPtr(self):
        r"""getArrayPtr(SoSpecularColorElement self) -> SbColor"""
        return _coin.SoSpecularColorElement_getArrayPtr(self)

# Register SoSpecularColorElement in _coin:
_coin.SoSpecularColorElement_swigregister(SoSpecularColorElement)
class SoEmissiveColorElement(SoReplacedElement):
    r"""Proxy of C++ SoEmissiveColorElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEmissiveColorElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoEmissiveColorElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoEmissiveColorElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoEmissiveColorElement_initClass()

    def init(self, state):
        r"""init(SoEmissiveColorElement self, SoState state)"""
        return _coin.SoEmissiveColorElement_init(self, state)

    @staticmethod
    def set(state, node, numcolors, colors):
        r"""set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
        return _coin.SoEmissiveColorElement_set(state, node, numcolors, colors)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoEmissiveColorElement"""
        return _coin.SoEmissiveColorElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoEmissiveColorElement self) -> int32_t"""
        return _coin.SoEmissiveColorElement_getNum(self)

    def get(self, index):
        r"""get(SoEmissiveColorElement self, int const index) -> SbColor"""
        return _coin.SoEmissiveColorElement_get(self, index)

    def getArrayPtr(self):
        r"""getArrayPtr(SoEmissiveColorElement self) -> SbColor"""
        return _coin.SoEmissiveColorElement_getArrayPtr(self)

# Register SoEmissiveColorElement in _coin:
_coin.SoEmissiveColorElement_swigregister(SoEmissiveColorElement)
class SoShininessElement(SoReplacedElement):
    r"""Proxy of C++ SoShininessElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShininessElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoShininessElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoShininessElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShininessElement_initClass()

    def init(self, state):
        r"""init(SoShininessElement self, SoState state)"""
        return _coin.SoShininessElement_init(self, state)

    @staticmethod
    def set(state, node, numvalues, values):
        r"""set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
        return _coin.SoShininessElement_set(state, node, numvalues, values)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoShininessElement"""
        return _coin.SoShininessElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoShininessElement self) -> int32_t"""
        return _coin.SoShininessElement_getNum(self)

    def get(self, index):
        r"""get(SoShininessElement self, int const index) -> float"""
        return _coin.SoShininessElement_get(self, index)

    def getArrayPtr(self):
        r"""getArrayPtr(SoShininessElement self) -> float const *"""
        return _coin.SoShininessElement_getArrayPtr(self)

# Register SoShininessElement in _coin:
_coin.SoShininessElement_swigregister(SoShininessElement)
class SoTransparencyElement(SoReplacedElement):
    r"""Proxy of C++ SoTransparencyElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransparencyElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTransparencyElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTransparencyElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransparencyElement_initClass()

    def init(self, state):
        r"""init(SoTransparencyElement self, SoState state)"""
        return _coin.SoTransparencyElement_init(self, state)

    @staticmethod
    def set(state, node, numvalues, values):
        r"""set(SoState state, SoNode node, int32_t const numvalues, float const *const values)"""
        return _coin.SoTransparencyElement_set(state, node, numvalues, values)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoTransparencyElement"""
        return _coin.SoTransparencyElement_getInstance(state)

    def getNum(self):
        r"""getNum(SoTransparencyElement self) -> int32_t"""
        return _coin.SoTransparencyElement_getNum(self)

    def get(self, index):
        r"""get(SoTransparencyElement self, int const index) -> float"""
        return _coin.SoTransparencyElement_get(self, index)

    def getArrayPtr(self):
        r"""getArrayPtr(SoTransparencyElement self) -> float const *"""
        return _coin.SoTransparencyElement_getArrayPtr(self)

# Register SoTransparencyElement in _coin:
_coin.SoTransparencyElement_swigregister(SoTransparencyElement)
class SoLightModelElement(SoInt32Element):
    r"""Proxy of C++ SoLightModelElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightModelElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoLightModelElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoLightModelElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLightModelElement_initClass()
    BASE_COLOR = _coin.SoLightModelElement_BASE_COLOR
    
    PHONG = _coin.SoLightModelElement_PHONG
    

    def init(self, state):
        r"""init(SoLightModelElement self, SoState state)"""
        return _coin.SoLightModelElement_init(self, state)

    @staticmethod
    def set(*args):
        r"""
        set(SoState state, SoLightModelElement::Model const model)
        set(SoState state, SoNode node, SoLightModelElement::Model const model)
        """
        return _coin.SoLightModelElement_set(*args)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> SoLightModelElement::Model"""
        return _coin.SoLightModelElement_get(state)

    @staticmethod
    def getDefault():
        r"""getDefault() -> SoLightModelElement::Model"""
        return _coin.SoLightModelElement_getDefault()

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoLightModelElement"""
        return _coin.SoLightModelElement_getInstance(state)

# Register SoLightModelElement in _coin:
_coin.SoLightModelElement_swigregister(SoLightModelElement)
class SoMultiTextureCoordinateElement(SoElement):
    r"""Proxy of C++ SoMultiTextureCoordinateElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoMultiTextureCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMultiTextureCoordinateElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMultiTextureCoordinateElement_initClass()

    def init(self, state):
        r"""init(SoMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoMultiTextureCoordinateElement_init(self, state)

    @staticmethod
    def setDefault(state, node, unit):
        r"""setDefault(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureCoordinateElement_setDefault(state, node, unit)

    @staticmethod
    def set2(state, node, unit, numCoords, coords):
        r"""set2(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec2f coords)"""
        return _coin.SoMultiTextureCoordinateElement_set2(state, node, unit, numCoords, coords)

    @staticmethod
    def set3(state, node, unit, numCoords, coords):
        r"""set3(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec3f coords)"""
        return _coin.SoMultiTextureCoordinateElement_set3(state, node, unit, numCoords, coords)

    @staticmethod
    def set4(state, node, unit, numCoords, coords):
        r"""set4(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec4f coords)"""
        return _coin.SoMultiTextureCoordinateElement_set4(state, node, unit, numCoords, coords)

    def getType(self, *args):
        r"""
        getType(SoMultiTextureCoordinateElement self, SoState state, int const unit) -> SoTextureCoordinateElement::CoordType
        getType(SoMultiTextureCoordinateElement self, int const unit) -> SoTextureCoordinateElement::CoordType
        """
        return _coin.SoMultiTextureCoordinateElement_getType(self, *args)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
        return _coin.SoMultiTextureCoordinateElement_getInstance(state)

    def get(self, unit, point, normal):
        r"""get(SoMultiTextureCoordinateElement self, int const unit, SbVec3f point, SbVec3f normal) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_get(self, unit, point, normal)

    def getNum(self, unit):
        r"""getNum(SoMultiTextureCoordinateElement self, int const unit) -> int32_t"""
        return _coin.SoMultiTextureCoordinateElement_getNum(self, unit)

    def is2D(self, unit):
        r"""is2D(SoMultiTextureCoordinateElement self, int const unit) -> SbBool"""
        return _coin.SoMultiTextureCoordinateElement_is2D(self, unit)

    def getDimension(self, unit):
        r"""getDimension(SoMultiTextureCoordinateElement self, int const unit) -> int32_t"""
        return _coin.SoMultiTextureCoordinateElement_getDimension(self, unit)

    def get2(self, unit, index):
        r"""get2(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec2f"""
        return _coin.SoMultiTextureCoordinateElement_get2(self, unit, index)

    def get3(self, unit, index):
        r"""get3(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec3f"""
        return _coin.SoMultiTextureCoordinateElement_get3(self, unit, index)

    def get4(self, unit, index):
        r"""get4(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_get4(self, unit, index)

    def getArrayPtr2(self, unit):
        r"""getArrayPtr2(SoMultiTextureCoordinateElement self, int const unit) -> SbVec2f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr2(self, unit)

    def getArrayPtr3(self, unit):
        r"""getArrayPtr3(SoMultiTextureCoordinateElement self, int const unit) -> SbVec3f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr3(self, unit)

    def getArrayPtr4(self, unit):
        r"""getArrayPtr4(SoMultiTextureCoordinateElement self, int const unit) -> SbVec4f"""
        return _coin.SoMultiTextureCoordinateElement_getArrayPtr4(self, unit)

    def push(self, state):
        r"""push(SoMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoMultiTextureCoordinateElement_push(self, state)

    def matches(self, elem):
        r"""matches(SoMultiTextureCoordinateElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureCoordinateElement_matches(self, elem)

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoMultiTextureCoordinateElement self) -> SoElement"""
        return _coin.SoMultiTextureCoordinateElement_copyMatchInfo(self)

# Register SoMultiTextureCoordinateElement in _coin:
_coin.SoMultiTextureCoordinateElement_swigregister(SoMultiTextureCoordinateElement)
class SoGLMultiTextureCoordinateElement(SoMultiTextureCoordinateElement):
    r"""Proxy of C++ SoGLMultiTextureCoordinateElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureCoordinateElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureCoordinateElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLMultiTextureCoordinateElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLMultiTextureCoordinateElement_initClass()

    def init(self, state):
        r"""init(SoGLMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_init(self, state)

    def push(self, state):
        r"""push(SoGLMultiTextureCoordinateElement self, SoState state)"""
        return _coin.SoGLMultiTextureCoordinateElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLMultiTextureCoordinateElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureCoordinateElement_pop(self, state, prevTopElement)

    def getType(self, unit):
        r"""getType(SoGLMultiTextureCoordinateElement self, int const unit) -> SoTextureCoordinateElement::CoordType"""
        return _coin.SoGLMultiTextureCoordinateElement_getType(self, unit)

    @staticmethod
    def getInstance(state):
        r"""getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
        return _coin.SoGLMultiTextureCoordinateElement_getInstance(state)

    def send(self, *args):
        r"""
        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):
        r"""initRender(SoGLMultiTextureCoordinateElement self, SbBool const * enabled, int const maxenabled)"""
        return _coin.SoGLMultiTextureCoordinateElement_initRender(self, enabled, maxenabled)

# Register SoGLMultiTextureCoordinateElement in _coin:
_coin.SoGLMultiTextureCoordinateElement_swigregister(SoGLMultiTextureCoordinateElement)
class SoMultiTextureEnabledElement(SoElement):
    r"""Proxy of C++ SoMultiTextureEnabledElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureEnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoMultiTextureEnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMultiTextureEnabledElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMultiTextureEnabledElement_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):
        r"""init(SoMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoMultiTextureEnabledElement_init(self, state)

    @staticmethod
    def set(state, node, unit, enabled):
        r"""set(SoState state, SoNode node, int const unit, SbBool const enabled)"""
        return _coin.SoMultiTextureEnabledElement_set(state, node, unit, enabled)

    @staticmethod
    def get(state, unit):
        r"""get(SoState state, int const unit) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_get(state, unit)

    def setElt(self, unit, mode):
        r"""setElt(SoMultiTextureEnabledElement self, int const unit, int const mode)"""
        return _coin.SoMultiTextureEnabledElement_setElt(self, unit, mode)

    def push(self, state):
        r"""push(SoMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoMultiTextureEnabledElement_push(self, state)

    def matches(self, elem):
        r"""matches(SoMultiTextureEnabledElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureEnabledElement_matches(self, elem)

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoMultiTextureEnabledElement self) -> SoElement"""
        return _coin.SoMultiTextureEnabledElement_copyMatchInfo(self)

    @staticmethod
    def getEnabledUnits(state, lastenabled):
        r"""getEnabledUnits(SoState state, int & lastenabled) -> SbBool const *"""
        return _coin.SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled)

    @staticmethod
    def getActiveUnits(state, lastenabled):
        r"""getActiveUnits(SoState state, int & lastenabled) -> SoMultiTextureEnabledElement::Mode const *"""
        return _coin.SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled)

    @staticmethod
    def enableRectangle(state, node, unit):
        r"""enableRectangle(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureEnabledElement_enableRectangle(state, node, unit)

    @staticmethod
    def enableCubeMap(state, node, unit):
        r"""enableCubeMap(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureEnabledElement_enableCubeMap(state, node, unit)

    @staticmethod
    def getMode(state, unit):
        r"""getMode(SoState state, int const unit) -> SoMultiTextureEnabledElement::Mode"""
        return _coin.SoMultiTextureEnabledElement_getMode(state, unit)

    @staticmethod
    def disableAll(state):
        r"""disableAll(SoState state)"""
        return _coin.SoMultiTextureEnabledElement_disableAll(state)

# Register SoMultiTextureEnabledElement in _coin:
_coin.SoMultiTextureEnabledElement_swigregister(SoMultiTextureEnabledElement)
class SoGLMultiTextureEnabledElement(SoMultiTextureEnabledElement):
    r"""Proxy of C++ SoGLMultiTextureEnabledElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureEnabledElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureEnabledElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLMultiTextureEnabledElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLMultiTextureEnabledElement_initClass()

    def init(self, state):
        r"""init(SoGLMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoGLMultiTextureEnabledElement_init(self, state)

    def push(self, state):
        r"""push(SoGLMultiTextureEnabledElement self, SoState state)"""
        return _coin.SoGLMultiTextureEnabledElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLMultiTextureEnabledElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureEnabledElement_pop(self, state, prevTopElement)

    def setElt(self, unit, mode):
        r"""setElt(SoGLMultiTextureEnabledElement self, int const unit, int const mode)"""
        return _coin.SoGLMultiTextureEnabledElement_setElt(self, unit, mode)

# Register SoGLMultiTextureEnabledElement in _coin:
_coin.SoGLMultiTextureEnabledElement_swigregister(SoGLMultiTextureEnabledElement)
class SoMultiTextureImageElement(SoElement):
    r"""Proxy of C++ SoMultiTextureImageElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureImageElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoMultiTextureImageElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMultiTextureImageElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMultiTextureImageElement_initClass()

    def init(self, state):
        r"""init(SoMultiTextureImageElement self, SoState state)"""
        return _coin.SoMultiTextureImageElement_init(self, state)

    @staticmethod
    def setDefault(state, node, unit):
        r"""setDefault(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureImageElement_setDefault(state, node, unit)

    @staticmethod
    def set(*args):
        r"""
        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)

    @staticmethod
    def get(*args):
        r"""
        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)

    @staticmethod
    def getImage(*args):
        r"""
        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)

    @staticmethod
    def getBlendColor(state, unit):
        r"""getBlendColor(SoState state, int const unit) -> SbColor"""
        return _coin.SoMultiTextureImageElement_getBlendColor(state, unit)

    @staticmethod
    def getModel(state, unit):
        r"""getModel(SoState state, int const unit) -> SoTextureImageElement::Model"""
        return _coin.SoMultiTextureImageElement_getModel(state, unit)

    @staticmethod
    def getWrapS(state, unit):
        r"""getWrapS(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapS(state, unit)

    @staticmethod
    def getWrapT(state, unit):
        r"""getWrapT(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapT(state, unit)

    @staticmethod
    def getWrapR(state, unit):
        r"""getWrapR(SoState state, int const unit) -> SoTextureImageElement::Wrap"""
        return _coin.SoMultiTextureImageElement_getWrapR(state, unit)

    @staticmethod
    def containsTransparency(state):
        r"""containsTransparency(SoState state) -> SbBool"""
        return _coin.SoMultiTextureImageElement_containsTransparency(state)

    @staticmethod
    def getDefault(*args):
        r"""
        getDefault(SbVec2s size, int & numComponents) -> unsigned char const
        getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
        """
        return _coin.SoMultiTextureImageElement_getDefault(*args)

    def push(self, state):
        r"""push(SoMultiTextureImageElement self, SoState state)"""
        return _coin.SoMultiTextureImageElement_push(self, state)

    def matches(self, elem):
        r"""matches(SoMultiTextureImageElement self, SoElement elem) -> SbBool"""
        return _coin.SoMultiTextureImageElement_matches(self, elem)

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoMultiTextureImageElement self) -> SoElement"""
        return _coin.SoMultiTextureImageElement_copyMatchInfo(self)

    def setElt(self, *args):
        r"""
        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):
        r"""hasTransparency(SoMultiTextureImageElement self, int const unit) -> SbBool"""
        return _coin.SoMultiTextureImageElement_hasTransparency(self, unit)

# Register SoMultiTextureImageElement in _coin:
_coin.SoMultiTextureImageElement_swigregister(SoMultiTextureImageElement)
class SoGLMultiTextureImageElement(SoMultiTextureImageElement):
    r"""Proxy of C++ SoGLMultiTextureImageElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureImageElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureImageElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLMultiTextureImageElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLMultiTextureImageElement_initClass()

    def init(self, state):
        r"""init(SoGLMultiTextureImageElement self, SoState state)"""
        return _coin.SoGLMultiTextureImageElement_init(self, state)

    def push(self, state):
        r"""push(SoGLMultiTextureImageElement self, SoState state)"""
        return _coin.SoGLMultiTextureImageElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLMultiTextureImageElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureImageElement_pop(self, state, prevTopElement)

    @staticmethod
    def set(state, node, unit, image, model, blendColor):
        r"""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)

    @staticmethod
    def restore(state, unit):
        r"""restore(SoState state, int const unit)"""
        return _coin.SoGLMultiTextureImageElement_restore(state, unit)

    @staticmethod
    def get(state, unit, model, blendcolor):
        r"""get(SoState state, int const unit, SoTextureImageElement::Model & model, SbColor blendcolor) -> SoGLImage"""
        return _coin.SoGLMultiTextureImageElement_get(state, unit, model, blendcolor)

    @staticmethod
    def hasTransparency(state):
        r"""hasTransparency(SoState state) -> SbBool"""
        return _coin.SoGLMultiTextureImageElement_hasTransparency(state)

# Register SoGLMultiTextureImageElement in _coin:
_coin.SoGLMultiTextureImageElement_swigregister(SoGLMultiTextureImageElement)
class SoMultiTextureMatrixElement(SoAccumulatedElement):
    r"""Proxy of C++ SoMultiTextureMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultiTextureMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoMultiTextureMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMultiTextureMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMultiTextureMatrixElement_initClass()

    def init(self, state):
        r"""init(SoMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoMultiTextureMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoMultiTextureMatrixElement_push(self, state)

    @staticmethod
    def set(state, node, unit):
        r"""set(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureMatrixElement_set(state, node, unit)

    @staticmethod
    def mult(state, node, unit):
        r"""mult(SoState state, SoNode node, int const unit)"""
        return _coin.SoMultiTextureMatrixElement_mult(state, node, unit)

    @staticmethod
    def get(state, unit):
        r"""get(SoState state, int const unit) -> SbMatrix"""
        return _coin.SoMultiTextureMatrixElement_get(state, unit)

# Register SoMultiTextureMatrixElement in _coin:
_coin.SoMultiTextureMatrixElement_swigregister(SoMultiTextureMatrixElement)
class SoGLMultiTextureMatrixElement(SoMultiTextureMatrixElement):
    r"""Proxy of C++ SoGLMultiTextureMatrixElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLMultiTextureMatrixElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoGLMultiTextureMatrixElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGLMultiTextureMatrixElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLMultiTextureMatrixElement_initClass()

    def init(self, state):
        r"""init(SoGLMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoGLMultiTextureMatrixElement_init(self, state)

    def push(self, state):
        r"""push(SoGLMultiTextureMatrixElement self, SoState state)"""
        return _coin.SoGLMultiTextureMatrixElement_push(self, state)

    def pop(self, state, prevTopElement):
        r"""pop(SoGLMultiTextureMatrixElement self, SoState state, SoElement prevTopElement)"""
        return _coin.SoGLMultiTextureMatrixElement_pop(self, state, prevTopElement)

    def multElt(self, unit):
        r"""multElt(SoGLMultiTextureMatrixElement self, int const unit)"""
        return _coin.SoGLMultiTextureMatrixElement_multElt(self, unit)

    def setElt(self, unit):
        r"""setElt(SoGLMultiTextureMatrixElement self, int const unit)"""
        return _coin.SoGLMultiTextureMatrixElement_setElt(self, unit)

# Register SoGLMultiTextureMatrixElement in _coin:
_coin.SoGLMultiTextureMatrixElement_swigregister(SoGLMultiTextureMatrixElement)
class SbColor4f(SbVec4f):
    r"""Proxy of C++ SbColor4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbColor4f_swiginit(self, _coin.new_SbColor4f(*args))

    def setValue(self, *args):
        r"""
        setValue(SbColor4f self, float const r, float const g, float const b, float const a=1.0)
        setValue(SbColor4f self, float const [4] col)
        """
        return _coin.SbColor4f_setValue(self, *args)

    def getValue(self):
        r"""getValue(SbColor4f self)"""
        return _coin.SbColor4f_getValue(self)

    def setRGB(self, col):
        r"""setRGB(SbColor4f self, SbColor col) -> SbColor4f"""
        return _coin.SbColor4f_setRGB(self, col)

    def getRGB(self, color):
        r"""getRGB(SbColor4f self, SbColor color)"""
        return _coin.SbColor4f_getRGB(self, color)

    def setHSVValue(self, *args):
        r"""
        setHSVValue(SbColor4f self, float h, float s, float v, float a=1.0) -> SbColor4f
        setHSVValue(SbColor4f self, float const [3] hsv, float alpha=1.0) -> SbColor4f
        """
        return _coin.SbColor4f_setHSVValue(self, *args)

    def getHSVValue(self):
        r"""getHSVValue(SbColor4f self)"""
        return _coin.SbColor4f_getHSVValue(self)

    def setPackedValue(self, rgba):
        r"""setPackedValue(SbColor4f self, uint32_t const rgba) -> SbColor4f"""
        return _coin.SbColor4f_setPackedValue(self, rgba)

    def getPackedValue(self):
        r"""getPackedValue(SbColor4f self) -> uint32_t"""
        return _coin.SbColor4f_getPackedValue(self)

    def __imul__(self, d):
        r"""__imul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbColor4f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, c):
        r"""__iadd__(SbColor4f self, SbColor4f c) -> SbColor4f"""
        return _coin.SbColor4f___iadd__(self, c)

    def __isub__(self, c):
        r"""__isub__(SbColor4f self, SbColor4f c) -> SbColor4f"""
        return _coin.SbColor4f___isub__(self, c)

    def __add__(self, u):
        r"""__add__(SbColor4f self, SbColor4f u) -> SbColor4f"""
        return _coin.SbColor4f___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbColor4f self, SbColor4f u) -> SbColor4f"""
        return _coin.SbColor4f___sub__(self, u)

    def __mul__(self, d):
        r"""__mul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___mul__(self, d)

    def __rmul__(self, d):
        r"""__rmul__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbColor4f self, float const d) -> SbColor4f"""
        return _coin.SbColor4f___div__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbColor4f self, SbColor4f u) -> int"""
        return _coin.SbColor4f___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbColor4f self, SbColor4f u) -> int"""
        return _coin.SbColor4f___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbColor4f self, int i) -> float"""
        return _coin.SbColor4f___getitem__(self, i)
    __swig_destroy__ = _coin.delete_SbColor4f

# Register SbColor4f in _coin:
_coin.SbColor4f_swigregister(SbColor4f)
class SoTextureCombineElement(SoElement):
    r"""Proxy of C++ SoTextureCombineElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCombineElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureCombineElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureCombineElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCombineElement_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):
        r"""init(SoTextureCombineElement self, SoState state)"""
        return _coin.SoTextureCombineElement_init(self, state)

    @staticmethod
    def set(state, node, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale):
        r"""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)

    @staticmethod
    def isDefault(state, unit):
        r"""isDefault(SoState state, int const unit) -> SbBool"""
        return _coin.SoTextureCombineElement_isDefault(state, unit)

    @staticmethod
    def get(state, unit, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale):
        r"""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 push(self, state):
        r"""push(SoTextureCombineElement self, SoState state)"""
        return _coin.SoTextureCombineElement_push(self, state)

    def matches(self, elem):
        r"""matches(SoTextureCombineElement self, SoElement elem) -> SbBool"""
        return _coin.SoTextureCombineElement_matches(self, elem)

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoTextureCombineElement self) -> SoElement"""
        return _coin.SoTextureCombineElement_copyMatchInfo(self)

    def setElt(self, unit, nodeid, rgboperation, alphaoperation, rgbsource, alphasource, rgboperand, alphaoperand, constantcolor, rgbscale, alphascale):
        r"""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)

    @staticmethod
    def apply(state, unit):
        r"""apply(SoState state, int const unit)"""
        return _coin.SoTextureCombineElement_apply(state, unit)

# Register SoTextureCombineElement in _coin:
_coin.SoTextureCombineElement_swigregister(SoTextureCombineElement)
class SoTextureUnitElement(SoInt32Element):
    r"""Proxy of C++ SoTextureUnitElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureUnitElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoTextureUnitElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTextureUnitElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureUnitElement_initClass()

    def init(self, state):
        r"""init(SoTextureUnitElement self, SoState state)"""
        return _coin.SoTextureUnitElement_init(self, state)

    @staticmethod
    def set(state, node, units):
        r"""set(SoState state, SoNode node, int const units)"""
        return _coin.SoTextureUnitElement_set(state, node, units)

    @staticmethod
    def get(state):
        r"""get(SoState state) -> int"""
        return _coin.SoTextureUnitElement_get(state)

# Register SoTextureUnitElement in _coin:
_coin.SoTextureUnitElement_swigregister(SoTextureUnitElement)
class SoEngine(SoFieldContainer):
    r"""Proxy of C++ SoEngine class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoEngine_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoEngine_initClasses()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEngine_getClassTypeId()

    def evaluateWrapper(self):
        r"""evaluateWrapper(SoEngine self)"""
        return _coin.SoEngine_evaluateWrapper(self)

    def getOutputs(self, l):
        r"""getOutputs(SoEngine self, SoEngineOutputList l) -> int"""
        return _coin.SoEngine_getOutputs(self, l)

    def getOutput(self, outputname):
        r"""getOutput(SoEngine self, SbName outputname) -> SoEngineOutput"""
        return _coin.SoEngine_getOutput(self, outputname)

    def getOutputName(self, output, outputname):
        r"""getOutputName(SoEngine self, SoEngineOutput output, SbName outputname) -> SbBool"""
        return _coin.SoEngine_getOutputName(self, output, outputname)

    def getOutputData(self):
        r"""getOutputData(SoEngine self) -> SoEngineOutputData"""
        return _coin.SoEngine_getOutputData(self)

    @staticmethod
    def getByName(*args):
        r"""
        getByName(SbName name) -> SoEngine
        getByName(SbName name, SoEngineList el) -> int
        """
        return _coin.SoEngine_getByName(*args)

    def isNotifying(self):
        r"""isNotifying(SoEngine self) -> SbBool"""
        return _coin.SoEngine_isNotifying(self)

    def notify(self, nl):
        r"""notify(SoEngine self, SoNotList nl)"""
        return _coin.SoEngine_notify(self, nl)

    def copy(self):
        r"""copy(SoEngine self) -> SoEngine"""
        return _coin.SoEngine_copy(self)

    def copyThroughConnection(self):
        r"""copyThroughConnection(SoEngine self) -> SoFieldContainer"""
        return _coin.SoEngine_copyThroughConnection(self)

    def shouldCopy(self):
        r"""shouldCopy(SoEngine self) -> SbBool"""
        return _coin.SoEngine_shouldCopy(self)

    def writeInstance(self, out):
        r"""writeInstance(SoEngine self, SoOutput out)"""
        return _coin.SoEngine_writeInstance(self, out)

    def __getattr__(self, name):
        try:
            return SoFieldContainer.__getattr__(self, name)
        except AttributeError as e:
    ##############################################################
            if name == "this":
                raise AttributeError
    ##############################################################
            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__))



# Register SoEngine in _coin:
_coin.SoEngine_swigregister(SoEngine)
class SoEngineOutput(object):
    r"""Proxy of C++ SoEngineOutput class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoEngineOutput self) -> SoEngineOutput"""
        _coin.SoEngineOutput_swiginit(self, _coin.new_SoEngineOutput())
    __swig_destroy__ = _coin.delete_SoEngineOutput

    def getConnectionType(self):
        r"""getConnectionType(SoEngineOutput self) -> SoType"""
        return _coin.SoEngineOutput_getConnectionType(self)

    def getForwardConnections(self, fl):
        r"""getForwardConnections(SoEngineOutput self, SoFieldList fl) -> int"""
        return _coin.SoEngineOutput_getForwardConnections(self, fl)

    def enable(self, flag):
        r"""enable(SoEngineOutput self, SbBool const flag)"""
        return _coin.SoEngineOutput_enable(self, flag)

    def isEnabled(self):
        r"""isEnabled(SoEngineOutput self) -> SbBool"""
        return _coin.SoEngineOutput_isEnabled(self)

    def getContainer(self):
        r"""getContainer(SoEngineOutput self) -> SoEngine"""
        return _coin.SoEngineOutput_getContainer(self)

    def getNodeContainer(self):
        r"""getNodeContainer(SoEngineOutput self) -> SoNodeEngine"""
        return _coin.SoEngineOutput_getNodeContainer(self)

    def isNodeEngineOutput(self):
        r"""isNodeEngineOutput(SoEngineOutput self) -> SbBool"""
        return _coin.SoEngineOutput_isNodeEngineOutput(self)

    def setContainer(self, engine):
        r"""setContainer(SoEngineOutput self, SoEngine engine)"""
        return _coin.SoEngineOutput_setContainer(self, engine)

    def setNodeContainer(self, nodeengine):
        r"""setNodeContainer(SoEngineOutput self, SoNodeEngine nodeengine)"""
        return _coin.SoEngineOutput_setNodeContainer(self, nodeengine)

    def addConnection(self, f):
        r"""addConnection(SoEngineOutput self, SoField f)"""
        return _coin.SoEngineOutput_addConnection(self, f)

    def removeConnection(self, f):
        r"""removeConnection(SoEngineOutput self, SoField f)"""
        return _coin.SoEngineOutput_removeConnection(self, f)

    def getNumConnections(self):
        r"""getNumConnections(SoEngineOutput self) -> int"""
        return _coin.SoEngineOutput_getNumConnections(self)

    def prepareToWrite(self):
        r"""prepareToWrite(SoEngineOutput self)"""
        return _coin.SoEngineOutput_prepareToWrite(self)

    def doneWriting(self):
        r"""doneWriting(SoEngineOutput self)"""
        return _coin.SoEngineOutput_doneWriting(self)

    def touchSlaves(self, nl, donotify):
        r"""touchSlaves(SoEngineOutput self, SoNotList nl, SbBool donotify)"""
        return _coin.SoEngineOutput_touchSlaves(self, nl, donotify)

    def getFieldContainer(self):
        r"""getFieldContainer(SoEngineOutput self) -> SoFieldContainer"""
        return _coin.SoEngineOutput_getFieldContainer(self)

# Register SoEngineOutput in _coin:
_coin.SoEngineOutput_swigregister(SoEngineOutput)
class SoEngineOutputData(object):
    r"""Proxy of C++ SoEngineOutputData class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoEngineOutputData self) -> SoEngineOutputData
        __init__(SoEngineOutputData self, SoEngineOutputData data) -> SoEngineOutputData
        __init__(SoEngineOutputData self, int approxnum) -> SoEngineOutputData
        """
        _coin.SoEngineOutputData_swiginit(self, _coin.new_SoEngineOutputData(*args))
    __swig_destroy__ = _coin.delete_SoEngineOutputData

    def addOutput(self, *args):
        r"""
        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):
        r"""getNumOutputs(SoEngineOutputData self) -> int"""
        return _coin.SoEngineOutputData_getNumOutputs(self)

    def getOutputName(self, index):
        r"""getOutputName(SoEngineOutputData self, int index) -> SbName"""
        return _coin.SoEngineOutputData_getOutputName(self, index)

    def getOutput(self, *args):
        r"""
        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):
        r"""
        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):
        r"""getType(SoEngineOutputData self, int index) -> SoType"""
        return _coin.SoEngineOutputData_getType(self, index)

    def readDescriptions(self, input, engine):
        r"""readDescriptions(SoEngineOutputData self, SoInput input, SoEngine engine) -> SbBool"""
        return _coin.SoEngineOutputData_readDescriptions(self, input, engine)

    def writeDescriptions(self, out, engine):
        r"""writeDescriptions(SoEngineOutputData self, SoOutput out, SoEngine engine)"""
        return _coin.SoEngineOutputData_writeDescriptions(self, out, engine)

# Register SoEngineOutputData in _coin:
_coin.SoEngineOutputData_swigregister(SoEngineOutputData)
class SoMFBool(SoMField):
    r"""Proxy of C++ SoMFBool class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFBool self) -> SoMFBool"""
        _coin.SoMFBool_swiginit(self, _coin.new_SoMFBool())
    __swig_destroy__ = _coin.delete_SoMFBool

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFBool_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFBool_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFBool self) -> SoType"""
        return _coin.SoMFBool_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFBool self, SoField field)"""
        return _coin.SoMFBool_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFBool self, SoField field) -> SbBool"""
        return _coin.SoMFBool_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFBool self, SbBool value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFBool self, int const idx, SbBool value)"""
        return _coin.SoMFBool_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFBool self, SoMFBool field) -> SbBool"""
        return _coin.SoMFBool___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFBool self, SoMFBool field) -> SbBool"""
        return _coin.SoMFBool___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFBool self) -> SbBool *"""
        return _coin.SoMFBool_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFBool self)"""
        return _coin.SoMFBool_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        setValuesPointer(SoMFBool self, int const num, SbBool const * userdata)
        setValuesPointer(SoMFBool self, int const num, SbBool * userdata)
        """
        return _coin.SoMFBool_setValuesPointer(self, *args)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFBool_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoMFBool self, SbBool value)
        setValue(SoMFBool self, SoMFBool other)
        """
        return _coin.SoMFBool_setValue(self, *args)

    def __getitem__(self, i):
        r"""__getitem__(SoMFBool self, int i) -> SbBool const"""
        return _coin.SoMFBool___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFBool self, int i, SbBool value)"""
        return _coin.SoMFBool___setitem__(self, i, value)

    def getValues(self, i=0):
        r"""getValues(SoMFBool self, int i=0) -> SbBool const"""
        return _coin.SoMFBool_getValues(self, i)

# Register SoMFBool in _coin:
_coin.SoMFBool_swigregister(SoMFBool)
class SoMFEnum(SoMField):
    r"""Proxy of C++ SoMFEnum class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFEnum self) -> SoMFEnum"""
        _coin.SoMFEnum_swiginit(self, _coin.new_SoMFEnum())
    __swig_destroy__ = _coin.delete_SoMFEnum

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFEnum_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFEnum_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFEnum self) -> SoType"""
        return _coin.SoMFEnum_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFEnum self, SoField field)"""
        return _coin.SoMFEnum_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFEnum self, SoField field) -> SbBool"""
        return _coin.SoMFEnum_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFEnum self, int value, SbBool addifnotfound=0) -> 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):
        r"""__eq__(SoMFEnum self, SoMFEnum field) -> SbBool"""
        return _coin.SoMFEnum___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFEnum self, SoMFEnum field) -> SbBool"""
        return _coin.SoMFEnum___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFEnum self) -> int *"""
        return _coin.SoMFEnum_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFEnum self)"""
        return _coin.SoMFEnum_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFEnum_initClass()

    def set1Value(self, *args):
        r"""
        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):
        r"""setEnums(SoMFEnum self, int const num, int const *const values, SbName names)"""
        return _coin.SoMFEnum_setEnums(self, num, values, names)

    def getNumEnums(self):
        r"""getNumEnums(SoMFEnum self) -> int"""
        return _coin.SoMFEnum_getNumEnums(self)

    def getEnum(self, idx, name):
        r"""getEnum(SoMFEnum self, int const idx, SbName name) -> int"""
        return _coin.SoMFEnum_getEnum(self, idx, name)

    def __getitem__(self, i):
        r"""__getitem__(SoMFEnum self, int i) -> int const"""
        return _coin.SoMFEnum___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFEnum self, int i, int value)"""
        return _coin.SoMFEnum___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        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):
        r"""getValues(SoMFEnum self, int i=0) -> int const"""
        return _coin.SoMFEnum_getValues(self, i)

# Register SoMFEnum in _coin:
_coin.SoMFEnum_swigregister(SoMFEnum)
class SoBoolOperation(SoEngine):
    r"""Proxy of C++ SoBoolOperation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBoolOperation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoBoolOperation self) -> SoType"""
        return _coin.SoBoolOperation_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoBoolOperation self) -> SoFieldData"""
        return _coin.SoBoolOperation_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoBoolOperation self) -> SoEngineOutputData"""
        return _coin.SoBoolOperation_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoBoolOperation_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 = property(_coin.SoBoolOperation_a_get, _coin.SoBoolOperation_a_set, doc=r"""a : SoMFBool""")
    b = property(_coin.SoBoolOperation_b_get, _coin.SoBoolOperation_b_set, doc=r"""b : SoMFBool""")
    operation = property(_coin.SoBoolOperation_operation_get, _coin.SoBoolOperation_operation_set, doc=r"""operation : SoMFEnum""")
    output = property(_coin.SoBoolOperation_output_get, _coin.SoBoolOperation_output_set, doc=r"""output : SoEngineOutput""")
    inverse = property(_coin.SoBoolOperation_inverse_get, _coin.SoBoolOperation_inverse_set, doc=r"""inverse : SoEngineOutput""")

    def __init__(self):
        r"""__init__(SoBoolOperation self) -> SoBoolOperation"""
        _coin.SoBoolOperation_swiginit(self, _coin.new_SoBoolOperation())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBoolOperation_initClass()

# Register SoBoolOperation in _coin:
_coin.SoBoolOperation_swigregister(SoBoolOperation)
class SoMFFloat(SoMField):
    r"""Proxy of C++ SoMFFloat class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFFloat self) -> SoMFFloat"""
        _coin.SoMFFloat_swiginit(self, _coin.new_SoMFFloat())
    __swig_destroy__ = _coin.delete_SoMFFloat

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFFloat_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFFloat_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFFloat self) -> SoType"""
        return _coin.SoMFFloat_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFFloat self, SoField field)"""
        return _coin.SoMFFloat_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFFloat self, SoField field) -> SbBool"""
        return _coin.SoMFFloat_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFFloat self, float value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFFloat self, int const idx, float value)"""
        return _coin.SoMFFloat_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFFloat self, SoMFFloat field) -> SbBool"""
        return _coin.SoMFFloat___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFFloat self, SoMFFloat field) -> SbBool"""
        return _coin.SoMFFloat___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFFloat self) -> float *"""
        return _coin.SoMFFloat_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFFloat self)"""
        return _coin.SoMFFloat_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        setValuesPointer(SoMFFloat self, int const num, float const * userdata)
        setValuesPointer(SoMFFloat self, int const num, float * userdata)
        """
        return _coin.SoMFFloat_setValuesPointer(self, *args)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFFloat_initClass()

    def __getitem__(self, i):
        r"""__getitem__(SoMFFloat self, int i) -> float const"""
        return _coin.SoMFFloat___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFFloat self, int i, float value)"""
        return _coin.SoMFFloat___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        setValue(SoMFFloat self, float value)
        setValue(SoMFFloat self, SoMFFloat other)
        """
        return _coin.SoMFFloat_setValue(self, *args)

    def getValues(self, i=0):
        r"""getValues(SoMFFloat self, int i=0) -> float const"""
        return _coin.SoMFFloat_getValues(self, i)

# Register SoMFFloat in _coin:
_coin.SoMFFloat_swigregister(SoMFFloat)
class SoMFVec3f(SoMField):
    r"""Proxy of C++ SoMFVec3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec3f self) -> SoMFVec3f"""
        _coin.SoMFVec3f_swiginit(self, _coin.new_SoMFVec3f())
    __swig_destroy__ = _coin.delete_SoMFVec3f

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3f_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec3f self) -> SoType"""
        return _coin.SoMFVec3f_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec3f self, SoField field)"""
        return _coin.SoMFVec3f_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec3f self, SoField field) -> SbBool"""
        return _coin.SoMFVec3f_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec3f self, SbVec3f value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3f_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec3f self, SoMFVec3f field) -> SbBool"""
        return _coin.SoMFVec3f___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec3f self, SoMFVec3f field) -> SbBool"""
        return _coin.SoMFVec3f___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec3f self) -> SbVec3f"""
        return _coin.SoMFVec3f_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec3f self)"""
        return _coin.SoMFVec3f_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec3f_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):
        r"""
        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):
        r"""__getitem__(SoMFVec3f self, int i) -> SbVec3f"""
        return _coin.SoMFVec3f___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFVec3f self, int i, SbVec3f value)"""
        return _coin.SoMFVec3f___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        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):
        r"""getValues(SoMFVec3f self, int i=0) -> SbVec3f"""
        return _coin.SoMFVec3f_getValues(self, i)

# Register SoMFVec3f in _coin:
_coin.SoMFVec3f_swigregister(SoMFVec3f)
class SoMFString(SoMField):
    r"""Proxy of C++ SoMFString class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFString self) -> SoMFString"""
        _coin.SoMFString_swiginit(self, _coin.new_SoMFString())
    __swig_destroy__ = _coin.delete_SoMFString

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFString_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFString_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFString self) -> SoType"""
        return _coin.SoMFString_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFString self, SoField field)"""
        return _coin.SoMFString_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFString self, SoField field) -> SbBool"""
        return _coin.SoMFString_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFString self, SbString value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFString_find(self, value, addifnotfound)

    def set1Value(self, idx, value):
        r"""set1Value(SoMFString self, int const idx, SbString value)"""
        return _coin.SoMFString_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFString self, SoMFString field) -> SbBool"""
        return _coin.SoMFString___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFString self, SoMFString field) -> SbBool"""
        return _coin.SoMFString___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFString self) -> SbString"""
        return _coin.SoMFString_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFString self)"""
        return _coin.SoMFString_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFString_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):
        r"""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):
        r"""__getitem__(SoMFString self, int i) -> SbString"""
        return _coin.SoMFString___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFString self, int i, SbString value)"""
        return _coin.SoMFString___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        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):
        r"""getValues(SoMFString self, int i=0) -> SbString"""
        return _coin.SoMFString_getValues(self, i)

# Register SoMFString in _coin:
_coin.SoMFString_swigregister(SoMFString)
class SoCalculator(SoEngine):
    r"""Proxy of C++ SoCalculator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCalculator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCalculator self) -> SoType"""
        return _coin.SoCalculator_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoCalculator self) -> SoFieldData"""
        return _coin.SoCalculator_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoCalculator self) -> SoEngineOutputData"""
        return _coin.SoCalculator_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoCalculator_createInstance()
    a = property(_coin.SoCalculator_a_get, _coin.SoCalculator_a_set, doc=r"""a : SoMFFloat""")
    b = property(_coin.SoCalculator_b_get, _coin.SoCalculator_b_set, doc=r"""b : SoMFFloat""")
    c = property(_coin.SoCalculator_c_get, _coin.SoCalculator_c_set, doc=r"""c : SoMFFloat""")
    d = property(_coin.SoCalculator_d_get, _coin.SoCalculator_d_set, doc=r"""d : SoMFFloat""")
    e = property(_coin.SoCalculator_e_get, _coin.SoCalculator_e_set, doc=r"""e : SoMFFloat""")
    f = property(_coin.SoCalculator_f_get, _coin.SoCalculator_f_set, doc=r"""f : SoMFFloat""")
    g = property(_coin.SoCalculator_g_get, _coin.SoCalculator_g_set, doc=r"""g : SoMFFloat""")
    h = property(_coin.SoCalculator_h_get, _coin.SoCalculator_h_set, doc=r"""h : SoMFFloat""")
    A = property(_coin.SoCalculator_A_get, _coin.SoCalculator_A_set, doc=r"""A : SoMFVec3f""")
    B = property(_coin.SoCalculator_B_get, _coin.SoCalculator_B_set, doc=r"""B : SoMFVec3f""")
    C = property(_coin.SoCalculator_C_get, _coin.SoCalculator_C_set, doc=r"""C : SoMFVec3f""")
    D = property(_coin.SoCalculator_D_get, _coin.SoCalculator_D_set, doc=r"""D : SoMFVec3f""")
    E = property(_coin.SoCalculator_E_get, _coin.SoCalculator_E_set, doc=r"""E : SoMFVec3f""")
    F = property(_coin.SoCalculator_F_get, _coin.SoCalculator_F_set, doc=r"""F : SoMFVec3f""")
    G = property(_coin.SoCalculator_G_get, _coin.SoCalculator_G_set, doc=r"""G : SoMFVec3f""")
    H = property(_coin.SoCalculator_H_get, _coin.SoCalculator_H_set, doc=r"""H : SoMFVec3f""")
    expression = property(_coin.SoCalculator_expression_get, _coin.SoCalculator_expression_set, doc=r"""expression : SoMFString""")
    oa = property(_coin.SoCalculator_oa_get, _coin.SoCalculator_oa_set, doc=r"""oa : SoEngineOutput""")
    ob = property(_coin.SoCalculator_ob_get, _coin.SoCalculator_ob_set, doc=r"""ob : SoEngineOutput""")
    oc = property(_coin.SoCalculator_oc_get, _coin.SoCalculator_oc_set, doc=r"""oc : SoEngineOutput""")
    od = property(_coin.SoCalculator_od_get, _coin.SoCalculator_od_set, doc=r"""od : SoEngineOutput""")
    oA = property(_coin.SoCalculator_oA_get, _coin.SoCalculator_oA_set, doc=r"""oA : SoEngineOutput""")
    oB = property(_coin.SoCalculator_oB_get, _coin.SoCalculator_oB_set, doc=r"""oB : SoEngineOutput""")
    oC = property(_coin.SoCalculator_oC_get, _coin.SoCalculator_oC_set, doc=r"""oC : SoEngineOutput""")
    oD = property(_coin.SoCalculator_oD_get, _coin.SoCalculator_oD_set, doc=r"""oD : SoEngineOutput""")

    def __init__(self):
        r"""__init__(SoCalculator self) -> SoCalculator"""
        _coin.SoCalculator_swiginit(self, _coin.new_SoCalculator())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCalculator_initClass()

# Register SoCalculator in _coin:
_coin.SoCalculator_swigregister(SoCalculator)
class SoMFVec2f(SoMField):
    r"""Proxy of C++ SoMFVec2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec2f self) -> SoMFVec2f"""
        _coin.SoMFVec2f_swiginit(self, _coin.new_SoMFVec2f())
    __swig_destroy__ = _coin.delete_SoMFVec2f

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2f_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec2f self) -> SoType"""
        return _coin.SoMFVec2f_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec2f self, SoField field)"""
        return _coin.SoMFVec2f_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec2f self, SoField field) -> SbBool"""
        return _coin.SoMFVec2f_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec2f self, SbVec2f value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2f_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec2f self, SoMFVec2f field) -> SbBool"""
        return _coin.SoMFVec2f___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec2f self, SoMFVec2f field) -> SbBool"""
        return _coin.SoMFVec2f___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec2f self) -> SbVec2f"""
        return _coin.SoMFVec2f_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec2f self)"""
        return _coin.SoMFVec2f_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec2f_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):
        r"""
        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):
        r"""__getitem__(SoMFVec2f self, int i) -> SbVec2f"""
        return _coin.SoMFVec2f___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFVec2f self, int i, SbVec2f value)"""
        return _coin.SoMFVec2f___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        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):
        r"""getValues(SoMFVec2f self, int i=0) -> SbVec2f"""
        return _coin.SoMFVec2f_getValues(self, i)

# Register SoMFVec2f in _coin:
_coin.SoMFVec2f_swigregister(SoMFVec2f)
class SoComposeVec2f(SoEngine):
    r"""Proxy of C++ SoComposeVec2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeVec2f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoComposeVec2f self) -> SoType"""
        return _coin.SoComposeVec2f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoComposeVec2f self) -> SoFieldData"""
        return _coin.SoComposeVec2f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoComposeVec2f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec2f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComposeVec2f_createInstance()

    def __init__(self):
        r"""__init__(SoComposeVec2f self) -> SoComposeVec2f"""
        _coin.SoComposeVec2f_swiginit(self, _coin.new_SoComposeVec2f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComposeVec2f_initClass()
    x = property(_coin.SoComposeVec2f_x_get, _coin.SoComposeVec2f_x_set, doc=r"""x : SoMFFloat""")
    y = property(_coin.SoComposeVec2f_y_get, _coin.SoComposeVec2f_y_set, doc=r"""y : SoMFFloat""")
    vector = property(_coin.SoComposeVec2f_vector_get, _coin.SoComposeVec2f_vector_set, doc=r"""vector : SoEngineOutput""")

# Register SoComposeVec2f in _coin:
_coin.SoComposeVec2f_swigregister(SoComposeVec2f)
class SoComposeVec3f(SoEngine):
    r"""Proxy of C++ SoComposeVec3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeVec3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoComposeVec3f self) -> SoType"""
        return _coin.SoComposeVec3f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoComposeVec3f self) -> SoFieldData"""
        return _coin.SoComposeVec3f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoComposeVec3f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec3f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComposeVec3f_createInstance()

    def __init__(self):
        r"""__init__(SoComposeVec3f self) -> SoComposeVec3f"""
        _coin.SoComposeVec3f_swiginit(self, _coin.new_SoComposeVec3f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComposeVec3f_initClass()
    x = property(_coin.SoComposeVec3f_x_get, _coin.SoComposeVec3f_x_set, doc=r"""x : SoMFFloat""")
    y = property(_coin.SoComposeVec3f_y_get, _coin.SoComposeVec3f_y_set, doc=r"""y : SoMFFloat""")
    z = property(_coin.SoComposeVec3f_z_get, _coin.SoComposeVec3f_z_set, doc=r"""z : SoMFFloat""")
    vector = property(_coin.SoComposeVec3f_vector_get, _coin.SoComposeVec3f_vector_set, doc=r"""vector : SoEngineOutput""")

# Register SoComposeVec3f in _coin:
_coin.SoComposeVec3f_swigregister(SoComposeVec3f)
class SoMFVec4f(SoMField):
    r"""Proxy of C++ SoMFVec4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec4f self) -> SoMFVec4f"""
        _coin.SoMFVec4f_swiginit(self, _coin.new_SoMFVec4f())
    __swig_destroy__ = _coin.delete_SoMFVec4f

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4f_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec4f self) -> SoType"""
        return _coin.SoMFVec4f_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec4f self, SoField field)"""
        return _coin.SoMFVec4f_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec4f self, SoField field) -> SbBool"""
        return _coin.SoMFVec4f_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec4f self, SbVec4f value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4f_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec4f self, SoMFVec4f field) -> SbBool"""
        return _coin.SoMFVec4f___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec4f self, SoMFVec4f field) -> SbBool"""
        return _coin.SoMFVec4f___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec4f self) -> SbVec4f"""
        return _coin.SoMFVec4f_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec4f self)"""
        return _coin.SoMFVec4f_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec4f_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):
        r"""
        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):
        r"""__getitem__(SoMFVec4f self, int i) -> SbVec4f"""
        return _coin.SoMFVec4f___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFVec4f self, int i, SbVec4f value)"""
        return _coin.SoMFVec4f___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        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):
        r"""getValues(SoMFVec4f self, int i=0) -> SbVec4f"""
        return _coin.SoMFVec4f_getValues(self, i)

# Register SoMFVec4f in _coin:
_coin.SoMFVec4f_swigregister(SoMFVec4f)
class SoComposeVec4f(SoEngine):
    r"""Proxy of C++ SoComposeVec4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeVec4f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoComposeVec4f self) -> SoType"""
        return _coin.SoComposeVec4f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoComposeVec4f self) -> SoFieldData"""
        return _coin.SoComposeVec4f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoComposeVec4f self) -> SoEngineOutputData"""
        return _coin.SoComposeVec4f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComposeVec4f_createInstance()

    def __init__(self):
        r"""__init__(SoComposeVec4f self) -> SoComposeVec4f"""
        _coin.SoComposeVec4f_swiginit(self, _coin.new_SoComposeVec4f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComposeVec4f_initClass()
    x = property(_coin.SoComposeVec4f_x_get, _coin.SoComposeVec4f_x_set, doc=r"""x : SoMFFloat""")
    y = property(_coin.SoComposeVec4f_y_get, _coin.SoComposeVec4f_y_set, doc=r"""y : SoMFFloat""")
    z = property(_coin.SoComposeVec4f_z_get, _coin.SoComposeVec4f_z_set, doc=r"""z : SoMFFloat""")
    w = property(_coin.SoComposeVec4f_w_get, _coin.SoComposeVec4f_w_set, doc=r"""w : SoMFFloat""")
    vector = property(_coin.SoComposeVec4f_vector_get, _coin.SoComposeVec4f_vector_set, doc=r"""vector : SoEngineOutput""")

# Register SoComposeVec4f in _coin:
_coin.SoComposeVec4f_swigregister(SoComposeVec4f)
class SoDecomposeVec2f(SoEngine):
    r"""Proxy of C++ SoDecomposeVec2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec2f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDecomposeVec2f self) -> SoType"""
        return _coin.SoDecomposeVec2f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoDecomposeVec2f self) -> SoFieldData"""
        return _coin.SoDecomposeVec2f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoDecomposeVec2f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec2f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeVec2f_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeVec2f self) -> SoDecomposeVec2f"""
        _coin.SoDecomposeVec2f_swiginit(self, _coin.new_SoDecomposeVec2f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDecomposeVec2f_initClass()
    vector = property(_coin.SoDecomposeVec2f_vector_get, _coin.SoDecomposeVec2f_vector_set, doc=r"""vector : SoMFVec2f""")
    x = property(_coin.SoDecomposeVec2f_x_get, _coin.SoDecomposeVec2f_x_set, doc=r"""x : SoEngineOutput""")
    y = property(_coin.SoDecomposeVec2f_y_get, _coin.SoDecomposeVec2f_y_set, doc=r"""y : SoEngineOutput""")

# Register SoDecomposeVec2f in _coin:
_coin.SoDecomposeVec2f_swigregister(SoDecomposeVec2f)
class SoDecomposeVec3f(SoEngine):
    r"""Proxy of C++ SoDecomposeVec3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDecomposeVec3f self) -> SoType"""
        return _coin.SoDecomposeVec3f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoDecomposeVec3f self) -> SoFieldData"""
        return _coin.SoDecomposeVec3f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoDecomposeVec3f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec3f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeVec3f_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeVec3f self) -> SoDecomposeVec3f"""
        _coin.SoDecomposeVec3f_swiginit(self, _coin.new_SoDecomposeVec3f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDecomposeVec3f_initClass()
    vector = property(_coin.SoDecomposeVec3f_vector_get, _coin.SoDecomposeVec3f_vector_set, doc=r"""vector : SoMFVec3f""")
    x = property(_coin.SoDecomposeVec3f_x_get, _coin.SoDecomposeVec3f_x_set, doc=r"""x : SoEngineOutput""")
    y = property(_coin.SoDecomposeVec3f_y_get, _coin.SoDecomposeVec3f_y_set, doc=r"""y : SoEngineOutput""")
    z = property(_coin.SoDecomposeVec3f_z_get, _coin.SoDecomposeVec3f_z_set, doc=r"""z : SoEngineOutput""")

# Register SoDecomposeVec3f in _coin:
_coin.SoDecomposeVec3f_swigregister(SoDecomposeVec3f)
class SoDecomposeVec4f(SoEngine):
    r"""Proxy of C++ SoDecomposeVec4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeVec4f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDecomposeVec4f self) -> SoType"""
        return _coin.SoDecomposeVec4f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoDecomposeVec4f self) -> SoFieldData"""
        return _coin.SoDecomposeVec4f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoDecomposeVec4f self) -> SoEngineOutputData"""
        return _coin.SoDecomposeVec4f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeVec4f_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeVec4f self) -> SoDecomposeVec4f"""
        _coin.SoDecomposeVec4f_swiginit(self, _coin.new_SoDecomposeVec4f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDecomposeVec4f_initClass()
    vector = property(_coin.SoDecomposeVec4f_vector_get, _coin.SoDecomposeVec4f_vector_set, doc=r"""vector : SoMFVec4f""")
    x = property(_coin.SoDecomposeVec4f_x_get, _coin.SoDecomposeVec4f_x_set, doc=r"""x : SoEngineOutput""")
    y = property(_coin.SoDecomposeVec4f_y_get, _coin.SoDecomposeVec4f_y_set, doc=r"""y : SoEngineOutput""")
    z = property(_coin.SoDecomposeVec4f_z_get, _coin.SoDecomposeVec4f_z_set, doc=r"""z : SoEngineOutput""")
    w = property(_coin.SoDecomposeVec4f_w_get, _coin.SoDecomposeVec4f_w_set, doc=r"""w : SoEngineOutput""")

# Register SoDecomposeVec4f in _coin:
_coin.SoDecomposeVec4f_swigregister(SoDecomposeVec4f)
class SoComposeRotation(SoEngine):
    r"""Proxy of C++ SoComposeRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeRotation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoComposeRotation self) -> SoType"""
        return _coin.SoComposeRotation_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoComposeRotation self) -> SoFieldData"""
        return _coin.SoComposeRotation_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoComposeRotation self) -> SoEngineOutputData"""
        return _coin.SoComposeRotation_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComposeRotation_createInstance()

    def __init__(self):
        r"""__init__(SoComposeRotation self) -> SoComposeRotation"""
        _coin.SoComposeRotation_swiginit(self, _coin.new_SoComposeRotation())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComposeRotation_initClass()
    axis = property(_coin.SoComposeRotation_axis_get, _coin.SoComposeRotation_axis_set, doc=r"""axis : SoMFVec3f""")
    angle = property(_coin.SoComposeRotation_angle_get, _coin.SoComposeRotation_angle_set, doc=r"""angle : SoMFFloat""")
    rotation = property(_coin.SoComposeRotation_rotation_get, _coin.SoComposeRotation_rotation_set, doc=r"""rotation : SoEngineOutput""")

# Register SoComposeRotation in _coin:
_coin.SoComposeRotation_swigregister(SoComposeRotation)
class SoMFRotation(SoMField):
    r"""Proxy of C++ SoMFRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFRotation self) -> SoMFRotation"""
        _coin.SoMFRotation_swiginit(self, _coin.new_SoMFRotation())
    __swig_destroy__ = _coin.delete_SoMFRotation

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFRotation_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFRotation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFRotation self) -> SoType"""
        return _coin.SoMFRotation_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFRotation self, SoField field)"""
        return _coin.SoMFRotation_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFRotation self, SoField field) -> SbBool"""
        return _coin.SoMFRotation_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFRotation self, SbRotation value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFRotation_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFRotation self, SoMFRotation field) -> SbBool"""
        return _coin.SoMFRotation___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFRotation self, SoMFRotation field) -> SbBool"""
        return _coin.SoMFRotation___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFRotation self) -> SbRotation"""
        return _coin.SoMFRotation_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFRotation self)"""
        return _coin.SoMFRotation_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFRotation_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):
        r"""
        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):
        r"""__getitem__(SoMFRotation self, int i) -> SbRotation"""
        return _coin.SoMFRotation___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFRotation self, int i, SbRotation value)"""
        return _coin.SoMFRotation___setitem__(self, i, value)

    def getValues(self, i=0):
        r"""getValues(SoMFRotation self, int i=0) -> SbRotation"""
        return _coin.SoMFRotation_getValues(self, i)

    def setValue(self, *args):
        r"""
        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)

# Register SoMFRotation in _coin:
_coin.SoMFRotation_swigregister(SoMFRotation)
class SoDecomposeRotation(SoEngine):
    r"""Proxy of C++ SoDecomposeRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeRotation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDecomposeRotation self) -> SoType"""
        return _coin.SoDecomposeRotation_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoDecomposeRotation self) -> SoFieldData"""
        return _coin.SoDecomposeRotation_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoDecomposeRotation self) -> SoEngineOutputData"""
        return _coin.SoDecomposeRotation_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeRotation_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeRotation self) -> SoDecomposeRotation"""
        _coin.SoDecomposeRotation_swiginit(self, _coin.new_SoDecomposeRotation())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDecomposeRotation_initClass()
    rotation = property(_coin.SoDecomposeRotation_rotation_get, _coin.SoDecomposeRotation_rotation_set, doc=r"""rotation : SoMFRotation""")
    axis = property(_coin.SoDecomposeRotation_axis_get, _coin.SoDecomposeRotation_axis_set, doc=r"""axis : SoEngineOutput""")
    angle = property(_coin.SoDecomposeRotation_angle_get, _coin.SoDecomposeRotation_angle_set, doc=r"""angle : SoEngineOutput""")

# Register SoDecomposeRotation in _coin:
_coin.SoDecomposeRotation_swigregister(SoDecomposeRotation)
class SoComposeMatrix(SoEngine):
    r"""Proxy of C++ SoComposeMatrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeMatrix_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoComposeMatrix self) -> SoType"""
        return _coin.SoComposeMatrix_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoComposeMatrix self) -> SoFieldData"""
        return _coin.SoComposeMatrix_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoComposeMatrix self) -> SoEngineOutputData"""
        return _coin.SoComposeMatrix_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComposeMatrix_createInstance()

    def __init__(self):
        r"""__init__(SoComposeMatrix self) -> SoComposeMatrix"""
        _coin.SoComposeMatrix_swiginit(self, _coin.new_SoComposeMatrix())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComposeMatrix_initClass()
    translation = property(_coin.SoComposeMatrix_translation_get, _coin.SoComposeMatrix_translation_set, doc=r"""translation : SoMFVec3f""")
    rotation = property(_coin.SoComposeMatrix_rotation_get, _coin.SoComposeMatrix_rotation_set, doc=r"""rotation : SoMFRotation""")
    scaleFactor = property(_coin.SoComposeMatrix_scaleFactor_get, _coin.SoComposeMatrix_scaleFactor_set, doc=r"""scaleFactor : SoMFVec3f""")
    scaleOrientation = property(_coin.SoComposeMatrix_scaleOrientation_get, _coin.SoComposeMatrix_scaleOrientation_set, doc=r"""scaleOrientation : SoMFRotation""")
    center = property(_coin.SoComposeMatrix_center_get, _coin.SoComposeMatrix_center_set, doc=r"""center : SoMFVec3f""")
    matrix = property(_coin.SoComposeMatrix_matrix_get, _coin.SoComposeMatrix_matrix_set, doc=r"""matrix : SoEngineOutput""")

# Register SoComposeMatrix in _coin:
_coin.SoComposeMatrix_swigregister(SoComposeMatrix)
class SoMFMatrix(SoMField):
    r"""Proxy of C++ SoMFMatrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFMatrix self) -> SoMFMatrix"""
        _coin.SoMFMatrix_swiginit(self, _coin.new_SoMFMatrix())
    __swig_destroy__ = _coin.delete_SoMFMatrix

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFMatrix_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFMatrix_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFMatrix self) -> SoType"""
        return _coin.SoMFMatrix_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFMatrix self, SoField field)"""
        return _coin.SoMFMatrix_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFMatrix self, SoField field) -> SbBool"""
        return _coin.SoMFMatrix_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFMatrix self, SbMatrix value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFMatrix self, int const idx, SbMatrix value)"""
        return _coin.SoMFMatrix_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFMatrix self, SoMFMatrix field) -> SbBool"""
        return _coin.SoMFMatrix___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFMatrix self, SoMFMatrix field) -> SbBool"""
        return _coin.SoMFMatrix___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFMatrix self) -> SbMatrix"""
        return _coin.SoMFMatrix_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFMatrix self)"""
        return _coin.SoMFMatrix_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFMatrix_initClass()

    def __getitem__(self, i):
        r"""__getitem__(SoMFMatrix self, int i) -> SbMatrix"""
        return _coin.SoMFMatrix___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFMatrix self, int i, SbMatrix value)"""
        return _coin.SoMFMatrix___setitem__(self, i, value)

    def getValues(self, i=0):
        r"""getValues(SoMFMatrix self, int i=0) -> SbMatrix"""
        return _coin.SoMFMatrix_getValues(self, i)

    def setValue(self, *args):
        r"""
        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)

# Register SoMFMatrix in _coin:
_coin.SoMFMatrix_swigregister(SoMFMatrix)
class SoDecomposeMatrix(SoEngine):
    r"""Proxy of C++ SoDecomposeMatrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDecomposeMatrix_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDecomposeMatrix self) -> SoType"""
        return _coin.SoDecomposeMatrix_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoDecomposeMatrix self) -> SoFieldData"""
        return _coin.SoDecomposeMatrix_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoDecomposeMatrix self) -> SoEngineOutputData"""
        return _coin.SoDecomposeMatrix_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoDecomposeMatrix_createInstance()

    def __init__(self):
        r"""__init__(SoDecomposeMatrix self) -> SoDecomposeMatrix"""
        _coin.SoDecomposeMatrix_swiginit(self, _coin.new_SoDecomposeMatrix())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDecomposeMatrix_initClass()
    matrix = property(_coin.SoDecomposeMatrix_matrix_get, _coin.SoDecomposeMatrix_matrix_set, doc=r"""matrix : SoMFMatrix""")
    center = property(_coin.SoDecomposeMatrix_center_get, _coin.SoDecomposeMatrix_center_set, doc=r"""center : SoMFVec3f""")
    translation = property(_coin.SoDecomposeMatrix_translation_get, _coin.SoDecomposeMatrix_translation_set, doc=r"""translation : SoEngineOutput""")
    rotation = property(_coin.SoDecomposeMatrix_rotation_get, _coin.SoDecomposeMatrix_rotation_set, doc=r"""rotation : SoEngineOutput""")
    scaleFactor = property(_coin.SoDecomposeMatrix_scaleFactor_get, _coin.SoDecomposeMatrix_scaleFactor_set, doc=r"""scaleFactor : SoEngineOutput""")
    scaleOrientation = property(_coin.SoDecomposeMatrix_scaleOrientation_get, _coin.SoDecomposeMatrix_scaleOrientation_set, doc=r"""scaleOrientation : SoEngineOutput""")

# Register SoDecomposeMatrix in _coin:
_coin.SoDecomposeMatrix_swigregister(SoDecomposeMatrix)
class SoComposeRotationFromTo(SoEngine):
    r"""Proxy of C++ SoComposeRotationFromTo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComposeRotationFromTo_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoComposeRotationFromTo self) -> SoType"""
        return _coin.SoComposeRotationFromTo_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoComposeRotationFromTo self) -> SoFieldData"""
        return _coin.SoComposeRotationFromTo_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoComposeRotationFromTo self) -> SoEngineOutputData"""
        return _coin.SoComposeRotationFromTo_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComposeRotationFromTo_createInstance()

    def __init__(self):
        r"""__init__(SoComposeRotationFromTo self) -> SoComposeRotationFromTo"""
        _coin.SoComposeRotationFromTo_swiginit(self, _coin.new_SoComposeRotationFromTo())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComposeRotationFromTo_initClass()
    srcFrom = property(_coin.SoComposeRotationFromTo_srcFrom_get, _coin.SoComposeRotationFromTo_srcFrom_set, doc=r"""srcFrom : SoMFVec3f""")
    destTo = property(_coin.SoComposeRotationFromTo_destTo_get, _coin.SoComposeRotationFromTo_destTo_set, doc=r"""destTo : SoMFVec3f""")
    rotation = property(_coin.SoComposeRotationFromTo_rotation_get, _coin.SoComposeRotationFromTo_rotation_set, doc=r"""rotation : SoEngineOutput""")

# Register SoComposeRotationFromTo in _coin:
_coin.SoComposeRotationFromTo_swigregister(SoComposeRotationFromTo)
class SoSFPath(SoSField):
    r"""Proxy of C++ SoSFPath class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFPath self) -> SoSFPath"""
        _coin.SoSFPath_swiginit(self, _coin.new_SoSFPath())
    __swig_destroy__ = _coin.delete_SoSFPath

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFPath_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFPath_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFPath self) -> SoType"""
        return _coin.SoSFPath_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFPath self, SoField field)"""
        return _coin.SoSFPath_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFPath self, SoField field) -> SbBool"""
        return _coin.SoSFPath_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFPath self) -> SoPath"""
        return _coin.SoSFPath_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFPath self, SoSFPath field) -> int"""
        return _coin.SoSFPath___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFPath self, SoSFPath field) -> int"""
        return _coin.SoSFPath___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFPath_initClass()

    def notify(self, l):
        r"""notify(SoSFPath self, SoNotList l)"""
        return _coin.SoSFPath_notify(self, l)

    def fixCopy(self, copyconnections):
        r"""fixCopy(SoSFPath self, SbBool copyconnections)"""
        return _coin.SoSFPath_fixCopy(self, copyconnections)

    def referencesCopy(self):
        r"""referencesCopy(SoSFPath self) -> SbBool"""
        return _coin.SoSFPath_referencesCopy(self)

    def setValue(self, *args):
        r"""
        setValue(SoSFPath self, SoPath newvalue)
        setValue(SoSFPath self, SoSFPath other)
        """
        return _coin.SoSFPath_setValue(self, *args)

# Register SoSFPath in _coin:
_coin.SoSFPath_swigregister(SoSFPath)
class SoComputeBoundingBox(SoEngine):
    r"""Proxy of C++ SoComputeBoundingBox class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoComputeBoundingBox_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoComputeBoundingBox self) -> SoType"""
        return _coin.SoComputeBoundingBox_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoComputeBoundingBox self) -> SoFieldData"""
        return _coin.SoComputeBoundingBox_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoComputeBoundingBox self) -> SoEngineOutputData"""
        return _coin.SoComputeBoundingBox_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoComputeBoundingBox_createInstance()
    node = property(_coin.SoComputeBoundingBox_node_get, _coin.SoComputeBoundingBox_node_set, doc=r"""node : SoSFNode""")
    path = property(_coin.SoComputeBoundingBox_path_get, _coin.SoComputeBoundingBox_path_set, doc=r"""path : SoSFPath""")
    min = property(_coin.SoComputeBoundingBox_min_get, _coin.SoComputeBoundingBox_min_set, doc=r"""min : SoEngineOutput""")
    max = property(_coin.SoComputeBoundingBox_max_get, _coin.SoComputeBoundingBox_max_set, doc=r"""max : SoEngineOutput""")
    boxCenter = property(_coin.SoComputeBoundingBox_boxCenter_get, _coin.SoComputeBoundingBox_boxCenter_set, doc=r"""boxCenter : SoEngineOutput""")
    objectCenter = property(_coin.SoComputeBoundingBox_objectCenter_get, _coin.SoComputeBoundingBox_objectCenter_set, doc=r"""objectCenter : SoEngineOutput""")

    def __init__(self):
        r"""__init__(SoComputeBoundingBox self) -> SoComputeBoundingBox"""
        _coin.SoComputeBoundingBox_swiginit(self, _coin.new_SoComputeBoundingBox())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoComputeBoundingBox_initClass()

    def setViewportRegion(self, vpr):
        r"""setViewportRegion(SoComputeBoundingBox self, SbViewportRegion vpr)"""
        return _coin.SoComputeBoundingBox_setViewportRegion(self, vpr)

    def getViewportRegion(self):
        r"""getViewportRegion(SoComputeBoundingBox self) -> SbViewportRegion"""
        return _coin.SoComputeBoundingBox_getViewportRegion(self)

# Register SoComputeBoundingBox in _coin:
_coin.SoComputeBoundingBox_swigregister(SoComputeBoundingBox)
class SoConcatenate(SoEngine):
    r"""Proxy of C++ SoConcatenate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoConcatenate_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoConcatenate self) -> SoType"""
        return _coin.SoConcatenate_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoConcatenate self) -> SoFieldData"""
        return _coin.SoConcatenate_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoConcatenate self) -> SoEngineOutputData"""
        return _coin.SoConcatenate_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoConcatenate_createInstance()
    NUMINPUTS = _coin.SoConcatenate_NUMINPUTS
    

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoConcatenate_initClass()

    def __init__(self, inputType):
        r"""__init__(SoConcatenate self, SoType inputType) -> SoConcatenate"""
        _coin.SoConcatenate_swiginit(self, _coin.new_SoConcatenate(inputType))
    input = property(_coin.SoConcatenate_input_get, _coin.SoConcatenate_input_set, doc=r"""input : a(SoConcatenate::NUMINPUTS).p.SoMField""")
    output = property(_coin.SoConcatenate_output_get, _coin.SoConcatenate_output_set, doc=r"""output : p.SoEngineOutput""")

# Register SoConcatenate in _coin:
_coin.SoConcatenate_swigregister(SoConcatenate)
class SoSFTrigger(SoSField):
    r"""Proxy of C++ SoSFTrigger class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFTrigger self) -> SoSFTrigger"""
        _coin.SoSFTrigger_swiginit(self, _coin.new_SoSFTrigger())
    __swig_destroy__ = _coin.delete_SoSFTrigger

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFTrigger_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFTrigger_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFTrigger self) -> SoType"""
        return _coin.SoSFTrigger_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFTrigger self, SoField field)"""
        return _coin.SoSFTrigger_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFTrigger self, SoField field) -> SbBool"""
        return _coin.SoSFTrigger_isSame(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFTrigger_initClass()

    def getValue(self):
        r"""getValue(SoSFTrigger self)"""
        return _coin.SoSFTrigger_getValue(self)

    def __eq__(self, trigger):
        r"""__eq__(SoSFTrigger self, SoSFTrigger trigger) -> int"""
        return _coin.SoSFTrigger___eq__(self, trigger)

    def __ne__(self, trigger):
        r"""__ne__(SoSFTrigger self, SoSFTrigger trigger) -> int"""
        return _coin.SoSFTrigger___ne__(self, trigger)

    def startNotify(self):
        r"""startNotify(SoSFTrigger self)"""
        return _coin.SoSFTrigger_startNotify(self)

    def notify(self, l):
        r"""notify(SoSFTrigger self, SoNotList l)"""
        return _coin.SoSFTrigger_notify(self, l)

    def touch(self):
        r"""touch(SoSFTrigger self)"""
        return _coin.SoSFTrigger_touch(self)

    def setValue(self, *args):
        r"""
        setValue(SoSFTrigger self)
        setValue(SoSFTrigger self, SoSFTrigger other)
        """
        return _coin.SoSFTrigger_setValue(self, *args)

# Register SoSFTrigger in _coin:
_coin.SoSFTrigger_swigregister(SoSFTrigger)
class SoSFShort(SoSField):
    r"""Proxy of C++ SoSFShort class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFShort self) -> SoSFShort"""
        _coin.SoSFShort_swiginit(self, _coin.new_SoSFShort())
    __swig_destroy__ = _coin.delete_SoSFShort

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFShort_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFShort_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFShort self) -> SoType"""
        return _coin.SoSFShort_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFShort self, SoField field)"""
        return _coin.SoSFShort_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFShort self, SoField field) -> SbBool"""
        return _coin.SoSFShort_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFShort self) -> short"""
        return _coin.SoSFShort_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFShort self, SoSFShort field) -> int"""
        return _coin.SoSFShort___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFShort self, SoSFShort field) -> int"""
        return _coin.SoSFShort___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFShort_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFShort self, short newvalue)
        setValue(SoSFShort self, SoSFShort other)
        """
        return _coin.SoSFShort_setValue(self, *args)

# Register SoSFShort in _coin:
_coin.SoSFShort_swigregister(SoSFShort)
class SoCounter(SoEngine):
    r"""Proxy of C++ SoCounter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCounter_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCounter self) -> SoType"""
        return _coin.SoCounter_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoCounter self) -> SoFieldData"""
        return _coin.SoCounter_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoCounter self) -> SoEngineOutputData"""
        return _coin.SoCounter_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoCounter_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCounter_initClass()

    def __init__(self):
        r"""__init__(SoCounter self) -> SoCounter"""
        _coin.SoCounter_swiginit(self, _coin.new_SoCounter())
    min = property(_coin.SoCounter_min_get, _coin.SoCounter_min_set, doc=r"""min : SoSFShort""")
    max = property(_coin.SoCounter_max_get, _coin.SoCounter_max_set, doc=r"""max : SoSFShort""")
    step = property(_coin.SoCounter_step_get, _coin.SoCounter_step_set, doc=r"""step : SoSFShort""")
    trigger = property(_coin.SoCounter_trigger_get, _coin.SoCounter_trigger_set, doc=r"""trigger : SoSFTrigger""")
    reset = property(_coin.SoCounter_reset_get, _coin.SoCounter_reset_set, doc=r"""reset : SoSFShort""")
    output = property(_coin.SoCounter_output_get, _coin.SoCounter_output_set, doc=r"""output : SoEngineOutput""")
    syncOut = property(_coin.SoCounter_syncOut_get, _coin.SoCounter_syncOut_set, doc=r"""syncOut : SoEngineOutput""")

# Register SoCounter in _coin:
_coin.SoCounter_swigregister(SoCounter)
class SoSFTime(SoSField):
    r"""Proxy of C++ SoSFTime class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFTime self) -> SoSFTime"""
        _coin.SoSFTime_swiginit(self, _coin.new_SoSFTime())
    __swig_destroy__ = _coin.delete_SoSFTime

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFTime_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFTime_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFTime self) -> SoType"""
        return _coin.SoSFTime_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFTime self, SoField field)"""
        return _coin.SoSFTime_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFTime self, SoField field) -> SbBool"""
        return _coin.SoSFTime_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFTime self) -> SbTime"""
        return _coin.SoSFTime_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFTime self, SoSFTime field) -> int"""
        return _coin.SoSFTime___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFTime self, SoSFTime field) -> int"""
        return _coin.SoSFTime___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFTime_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFTime self, SbTime newvalue)
        setValue(SoSFTime self, SbTime other)
        setValue(SoSFTime self, SoSFTime other)
        """
        return _coin.SoSFTime_setValue(self, *args)

# Register SoSFTime in _coin:
_coin.SoSFTime_swigregister(SoSFTime)
class SoElapsedTime(SoEngine):
    r"""Proxy of C++ SoElapsedTime class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoElapsedTime_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoElapsedTime self) -> SoType"""
        return _coin.SoElapsedTime_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoElapsedTime self) -> SoFieldData"""
        return _coin.SoElapsedTime_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoElapsedTime self) -> SoEngineOutputData"""
        return _coin.SoElapsedTime_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoElapsedTime_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoElapsedTime_initClass()

    def __init__(self):
        r"""__init__(SoElapsedTime self) -> SoElapsedTime"""
        _coin.SoElapsedTime_swiginit(self, _coin.new_SoElapsedTime())
    timeIn = property(_coin.SoElapsedTime_timeIn_get, _coin.SoElapsedTime_timeIn_set, doc=r"""timeIn : SoSFTime""")
    speed = property(_coin.SoElapsedTime_speed_get, _coin.SoElapsedTime_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoElapsedTime_on_get, _coin.SoElapsedTime_on_set, doc=r"""on : SoSFBool""")
    pause = property(_coin.SoElapsedTime_pause_get, _coin.SoElapsedTime_pause_set, doc=r"""pause : SoSFBool""")
    reset = property(_coin.SoElapsedTime_reset_get, _coin.SoElapsedTime_reset_set, doc=r"""reset : SoSFTrigger""")
    timeOut = property(_coin.SoElapsedTime_timeOut_get, _coin.SoElapsedTime_timeOut_set, doc=r"""timeOut : SoEngineOutput""")

# Register SoElapsedTime in _coin:
_coin.SoElapsedTime_swigregister(SoElapsedTime)
class SoFieldConverter(SoEngine):
    r"""Proxy of C++ SoFieldConverter class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFieldConverter_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoFieldConverter self) -> SoType"""
        return _coin.SoFieldConverter_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoFieldConverter self) -> SoFieldData"""
        return _coin.SoFieldConverter_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoFieldConverter self) -> SoEngineOutputData"""
        return _coin.SoFieldConverter_getOutputData(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFieldConverter_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoFieldConverter_initClasses()

    def getInput(self, type):
        r"""getInput(SoFieldConverter self, SoType type) -> SoField"""
        return _coin.SoFieldConverter_getInput(self, type)

    def getOutput(self, type):
        r"""getOutput(SoFieldConverter self, SoType type) -> SoEngineOutput"""
        return _coin.SoFieldConverter_getOutput(self, type)

    def getConnectedInput(self):
        r"""getConnectedInput(SoFieldConverter self) -> SoField"""
        return _coin.SoFieldConverter_getConnectedInput(self)

    def getForwardConnections(self, l):
        r"""getForwardConnections(SoFieldConverter self, SoFieldList l) -> int"""
        return _coin.SoFieldConverter_getForwardConnections(self, l)

# Register SoFieldConverter in _coin:
_coin.SoFieldConverter_swigregister(SoFieldConverter)
class SoGate(SoEngine):
    r"""Proxy of C++ SoGate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGate_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoGate self) -> SoType"""
        return _coin.SoGate_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoGate self) -> SoFieldData"""
        return _coin.SoGate_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoGate self) -> SoEngineOutputData"""
        return _coin.SoGate_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoGate_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGate_initClass()

    def __init__(self, type):
        r"""__init__(SoGate self, SoType type) -> SoGate"""
        _coin.SoGate_swiginit(self, _coin.new_SoGate(type))
    enable = property(_coin.SoGate_enable_get, _coin.SoGate_enable_set, doc=r"""enable : SoSFBool""")
    trigger = property(_coin.SoGate_trigger_get, _coin.SoGate_trigger_set, doc=r"""trigger : SoSFTrigger""")
    input = property(_coin.SoGate_input_get, _coin.SoGate_input_set, doc=r"""input : p.SoMField""")
    output = property(_coin.SoGate_output_get, _coin.SoGate_output_set, doc=r"""output : p.SoEngineOutput""")

# Register SoGate in _coin:
_coin.SoGate_swigregister(SoGate)
class SoInterpolate(SoEngine):
    r"""Proxy of C++ SoInterpolate class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolate_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoInterpolate self) -> SoType"""
        return _coin.SoInterpolate_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoInterpolate self) -> SoFieldData"""
        return _coin.SoInterpolate_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoInterpolate self) -> SoEngineOutputData"""
        return _coin.SoInterpolate_getOutputData(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInterpolate_initClass()

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.SoInterpolate_initClasses()
    alpha = property(_coin.SoInterpolate_alpha_get, _coin.SoInterpolate_alpha_set, doc=r"""alpha : SoSFFloat""")
    output = property(_coin.SoInterpolate_output_get, _coin.SoInterpolate_output_set, doc=r"""output : SoEngineOutput""")

# Register SoInterpolate in _coin:
_coin.SoInterpolate_swigregister(SoInterpolate)
class SoInterpolateFloat(SoInterpolate):
    r"""Proxy of C++ SoInterpolateFloat class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateFloat_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoInterpolateFloat self) -> SoType"""
        return _coin.SoInterpolateFloat_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoInterpolateFloat self) -> SoFieldData"""
        return _coin.SoInterpolateFloat_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoInterpolateFloat self) -> SoEngineOutputData"""
        return _coin.SoInterpolateFloat_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateFloat_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateFloat self) -> SoInterpolateFloat"""
        _coin.SoInterpolateFloat_swiginit(self, _coin.new_SoInterpolateFloat())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInterpolateFloat_initClass()
    input0 = property(_coin.SoInterpolateFloat_input0_get, _coin.SoInterpolateFloat_input0_set, doc=r"""input0 : SoMFFloat""")
    input1 = property(_coin.SoInterpolateFloat_input1_get, _coin.SoInterpolateFloat_input1_set, doc=r"""input1 : SoMFFloat""")

# Register SoInterpolateFloat in _coin:
_coin.SoInterpolateFloat_swigregister(SoInterpolateFloat)
class SoInterpolateVec2f(SoInterpolate):
    r"""Proxy of C++ SoInterpolateVec2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec2f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoInterpolateVec2f self) -> SoType"""
        return _coin.SoInterpolateVec2f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoInterpolateVec2f self) -> SoFieldData"""
        return _coin.SoInterpolateVec2f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoInterpolateVec2f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec2f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateVec2f_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateVec2f self) -> SoInterpolateVec2f"""
        _coin.SoInterpolateVec2f_swiginit(self, _coin.new_SoInterpolateVec2f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInterpolateVec2f_initClass()
    input0 = property(_coin.SoInterpolateVec2f_input0_get, _coin.SoInterpolateVec2f_input0_set, doc=r"""input0 : SoMFVec2f""")
    input1 = property(_coin.SoInterpolateVec2f_input1_get, _coin.SoInterpolateVec2f_input1_set, doc=r"""input1 : SoMFVec2f""")

# Register SoInterpolateVec2f in _coin:
_coin.SoInterpolateVec2f_swigregister(SoInterpolateVec2f)
class SoInterpolateVec3f(SoInterpolate):
    r"""Proxy of C++ SoInterpolateVec3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoInterpolateVec3f self) -> SoType"""
        return _coin.SoInterpolateVec3f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoInterpolateVec3f self) -> SoFieldData"""
        return _coin.SoInterpolateVec3f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoInterpolateVec3f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec3f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateVec3f_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateVec3f self) -> SoInterpolateVec3f"""
        _coin.SoInterpolateVec3f_swiginit(self, _coin.new_SoInterpolateVec3f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInterpolateVec3f_initClass()
    input0 = property(_coin.SoInterpolateVec3f_input0_get, _coin.SoInterpolateVec3f_input0_set, doc=r"""input0 : SoMFVec3f""")
    input1 = property(_coin.SoInterpolateVec3f_input1_get, _coin.SoInterpolateVec3f_input1_set, doc=r"""input1 : SoMFVec3f""")

# Register SoInterpolateVec3f in _coin:
_coin.SoInterpolateVec3f_swigregister(SoInterpolateVec3f)
class SoInterpolateVec4f(SoInterpolate):
    r"""Proxy of C++ SoInterpolateVec4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateVec4f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoInterpolateVec4f self) -> SoType"""
        return _coin.SoInterpolateVec4f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoInterpolateVec4f self) -> SoFieldData"""
        return _coin.SoInterpolateVec4f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoInterpolateVec4f self) -> SoEngineOutputData"""
        return _coin.SoInterpolateVec4f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateVec4f_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateVec4f self) -> SoInterpolateVec4f"""
        _coin.SoInterpolateVec4f_swiginit(self, _coin.new_SoInterpolateVec4f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInterpolateVec4f_initClass()
    input0 = property(_coin.SoInterpolateVec4f_input0_get, _coin.SoInterpolateVec4f_input0_set, doc=r"""input0 : SoMFVec4f""")
    input1 = property(_coin.SoInterpolateVec4f_input1_get, _coin.SoInterpolateVec4f_input1_set, doc=r"""input1 : SoMFVec4f""")

# Register SoInterpolateVec4f in _coin:
_coin.SoInterpolateVec4f_swigregister(SoInterpolateVec4f)
class SoInterpolateRotation(SoInterpolate):
    r"""Proxy of C++ SoInterpolateRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInterpolateRotation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoInterpolateRotation self) -> SoType"""
        return _coin.SoInterpolateRotation_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoInterpolateRotation self) -> SoFieldData"""
        return _coin.SoInterpolateRotation_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoInterpolateRotation self) -> SoEngineOutputData"""
        return _coin.SoInterpolateRotation_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoInterpolateRotation_createInstance()

    def __init__(self):
        r"""__init__(SoInterpolateRotation self) -> SoInterpolateRotation"""
        _coin.SoInterpolateRotation_swiginit(self, _coin.new_SoInterpolateRotation())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInterpolateRotation_initClass()
    input0 = property(_coin.SoInterpolateRotation_input0_get, _coin.SoInterpolateRotation_input0_set, doc=r"""input0 : SoMFRotation""")
    input1 = property(_coin.SoInterpolateRotation_input1_get, _coin.SoInterpolateRotation_input1_set, doc=r"""input1 : SoMFRotation""")

# Register SoInterpolateRotation in _coin:
_coin.SoInterpolateRotation_swigregister(SoInterpolateRotation)
class SoOnOff(SoEngine):
    r"""Proxy of C++ SoOnOff class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoOnOff_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoOnOff self) -> SoType"""
        return _coin.SoOnOff_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoOnOff self) -> SoFieldData"""
        return _coin.SoOnOff_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoOnOff self) -> SoEngineOutputData"""
        return _coin.SoOnOff_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoOnOff_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoOnOff_initClass()

    def __init__(self):
        r"""__init__(SoOnOff self) -> SoOnOff"""
        _coin.SoOnOff_swiginit(self, _coin.new_SoOnOff())
    on = property(_coin.SoOnOff_on_get, _coin.SoOnOff_on_set, doc=r"""on : SoSFTrigger""")
    off = property(_coin.SoOnOff_off_get, _coin.SoOnOff_off_set, doc=r"""off : SoSFTrigger""")
    toggle = property(_coin.SoOnOff_toggle_get, _coin.SoOnOff_toggle_set, doc=r"""toggle : SoSFTrigger""")
    isOn = property(_coin.SoOnOff_isOn_get, _coin.SoOnOff_isOn_set, doc=r"""isOn : SoEngineOutput""")
    isOff = property(_coin.SoOnOff_isOff_get, _coin.SoOnOff_isOff_set, doc=r"""isOff : SoEngineOutput""")

# Register SoOnOff in _coin:
_coin.SoOnOff_swigregister(SoOnOff)
class SoSFBitMask(SoSFEnum):
    r"""Proxy of C++ SoSFBitMask class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBitMask self) -> SoSFBitMask"""
        _coin.SoSFBitMask_swiginit(self, _coin.new_SoSFBitMask())
    __swig_destroy__ = _coin.delete_SoSFBitMask

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBitMask_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBitMask_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBitMask self) -> SoType"""
        return _coin.SoSFBitMask_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBitMask self, SoField field)"""
        return _coin.SoSFBitMask_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBitMask self, SoField field) -> SbBool"""
        return _coin.SoSFBitMask_isSame(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBitMask_initClass()

# Register SoSFBitMask in _coin:
_coin.SoSFBitMask_swigregister(SoSFBitMask)
class SoOneShot(SoEngine):
    r"""Proxy of C++ SoOneShot class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoOneShot_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoOneShot self) -> SoType"""
        return _coin.SoOneShot_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoOneShot self) -> SoFieldData"""
        return _coin.SoOneShot_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoOneShot self) -> SoEngineOutputData"""
        return _coin.SoOneShot_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoOneShot_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoOneShot_initClass()

    def __init__(self):
        r"""__init__(SoOneShot self) -> SoOneShot"""
        _coin.SoOneShot_swiginit(self, _coin.new_SoOneShot())
    RETRIGGERABLE = _coin.SoOneShot_RETRIGGERABLE
    
    HOLD_FINAL = _coin.SoOneShot_HOLD_FINAL
    
    timeIn = property(_coin.SoOneShot_timeIn_get, _coin.SoOneShot_timeIn_set, doc=r"""timeIn : SoSFTime""")
    duration = property(_coin.SoOneShot_duration_get, _coin.SoOneShot_duration_set, doc=r"""duration : SoSFTime""")
    trigger = property(_coin.SoOneShot_trigger_get, _coin.SoOneShot_trigger_set, doc=r"""trigger : SoSFTrigger""")
    flags = property(_coin.SoOneShot_flags_get, _coin.SoOneShot_flags_set, doc=r"""flags : SoSFBitMask""")
    disable = property(_coin.SoOneShot_disable_get, _coin.SoOneShot_disable_set, doc=r"""disable : SoSFBool""")
    timeOut = property(_coin.SoOneShot_timeOut_get, _coin.SoOneShot_timeOut_set, doc=r"""timeOut : SoEngineOutput""")
    isActive = property(_coin.SoOneShot_isActive_get, _coin.SoOneShot_isActive_set, doc=r"""isActive : SoEngineOutput""")
    ramp = property(_coin.SoOneShot_ramp_get, _coin.SoOneShot_ramp_set, doc=r"""ramp : SoEngineOutput""")

# Register SoOneShot in _coin:
_coin.SoOneShot_swigregister(SoOneShot)
class SoSelectOne(SoEngine):
    r"""Proxy of C++ SoSelectOne class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSelectOne_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSelectOne self) -> SoType"""
        return _coin.SoSelectOne_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoSelectOne self) -> SoFieldData"""
        return _coin.SoSelectOne_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoSelectOne self) -> SoEngineOutputData"""
        return _coin.SoSelectOne_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSelectOne_createInstance()
    index = property(_coin.SoSelectOne_index_get, _coin.SoSelectOne_index_set, doc=r"""index : SoSFInt32""")
    input = property(_coin.SoSelectOne_input_get, _coin.SoSelectOne_input_set, doc=r"""input : p.SoMField""")
    output = property(_coin.SoSelectOne_output_get, _coin.SoSelectOne_output_set, doc=r"""output : p.SoEngineOutput""")

    def __init__(self, inputtype):
        r"""__init__(SoSelectOne self, SoType inputtype) -> SoSelectOne"""
        _coin.SoSelectOne_swiginit(self, _coin.new_SoSelectOne(inputtype))

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSelectOne_initClass()

# Register SoSelectOne in _coin:
_coin.SoSelectOne_swigregister(SoSelectOne)
class SoTimeCounter(SoEngine):
    r"""Proxy of C++ SoTimeCounter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTimeCounter_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTimeCounter self) -> SoType"""
        return _coin.SoTimeCounter_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoTimeCounter self) -> SoFieldData"""
        return _coin.SoTimeCounter_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoTimeCounter self) -> SoEngineOutputData"""
        return _coin.SoTimeCounter_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTimeCounter_createInstance()
    timeIn = property(_coin.SoTimeCounter_timeIn_get, _coin.SoTimeCounter_timeIn_set, doc=r"""timeIn : SoSFTime""")
    min = property(_coin.SoTimeCounter_min_get, _coin.SoTimeCounter_min_set, doc=r"""min : SoSFShort""")
    max = property(_coin.SoTimeCounter_max_get, _coin.SoTimeCounter_max_set, doc=r"""max : SoSFShort""")
    step = property(_coin.SoTimeCounter_step_get, _coin.SoTimeCounter_step_set, doc=r"""step : SoSFShort""")
    on = property(_coin.SoTimeCounter_on_get, _coin.SoTimeCounter_on_set, doc=r"""on : SoSFBool""")
    frequency = property(_coin.SoTimeCounter_frequency_get, _coin.SoTimeCounter_frequency_set, doc=r"""frequency : SoSFFloat""")
    duty = property(_coin.SoTimeCounter_duty_get, _coin.SoTimeCounter_duty_set, doc=r"""duty : SoMFFloat""")
    reset = property(_coin.SoTimeCounter_reset_get, _coin.SoTimeCounter_reset_set, doc=r"""reset : SoSFShort""")
    syncIn = property(_coin.SoTimeCounter_syncIn_get, _coin.SoTimeCounter_syncIn_set, doc=r"""syncIn : SoSFTrigger""")
    output = property(_coin.SoTimeCounter_output_get, _coin.SoTimeCounter_output_set, doc=r"""output : SoEngineOutput""")
    syncOut = property(_coin.SoTimeCounter_syncOut_get, _coin.SoTimeCounter_syncOut_set, doc=r"""syncOut : SoEngineOutput""")

    def __init__(self):
        r"""__init__(SoTimeCounter self) -> SoTimeCounter"""
        _coin.SoTimeCounter_swiginit(self, _coin.new_SoTimeCounter())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTimeCounter_initClass()

# Register SoTimeCounter in _coin:
_coin.SoTimeCounter_swigregister(SoTimeCounter)
class SoTransformVec3f(SoEngine):
    r"""Proxy of C++ SoTransformVec3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformVec3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransformVec3f self) -> SoType"""
        return _coin.SoTransformVec3f_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoTransformVec3f self) -> SoFieldData"""
        return _coin.SoTransformVec3f_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoTransformVec3f self) -> SoEngineOutputData"""
        return _coin.SoTransformVec3f_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTransformVec3f_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransformVec3f_initClass()

    def __init__(self):
        r"""__init__(SoTransformVec3f self) -> SoTransformVec3f"""
        _coin.SoTransformVec3f_swiginit(self, _coin.new_SoTransformVec3f())
    vector = property(_coin.SoTransformVec3f_vector_get, _coin.SoTransformVec3f_vector_set, doc=r"""vector : SoMFVec3f""")
    matrix = property(_coin.SoTransformVec3f_matrix_get, _coin.SoTransformVec3f_matrix_set, doc=r"""matrix : SoMFMatrix""")
    point = property(_coin.SoTransformVec3f_point_get, _coin.SoTransformVec3f_point_set, doc=r"""point : SoEngineOutput""")
    direction = property(_coin.SoTransformVec3f_direction_get, _coin.SoTransformVec3f_direction_set, doc=r"""direction : SoEngineOutput""")
    normalDirection = property(_coin.SoTransformVec3f_normalDirection_get, _coin.SoTransformVec3f_normalDirection_set, doc=r"""normalDirection : SoEngineOutput""")

# Register SoTransformVec3f in _coin:
_coin.SoTransformVec3f_swigregister(SoTransformVec3f)
class SoTriggerAny(SoEngine):
    r"""Proxy of C++ SoTriggerAny class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTriggerAny_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTriggerAny self) -> SoType"""
        return _coin.SoTriggerAny_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoTriggerAny self) -> SoFieldData"""
        return _coin.SoTriggerAny_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoTriggerAny self) -> SoEngineOutputData"""
        return _coin.SoTriggerAny_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoTriggerAny_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTriggerAny_initClass()

    def __init__(self):
        r"""__init__(SoTriggerAny self) -> SoTriggerAny"""
        _coin.SoTriggerAny_swiginit(self, _coin.new_SoTriggerAny())
    input0 = property(_coin.SoTriggerAny_input0_get, _coin.SoTriggerAny_input0_set, doc=r"""input0 : SoSFTrigger""")
    input1 = property(_coin.SoTriggerAny_input1_get, _coin.SoTriggerAny_input1_set, doc=r"""input1 : SoSFTrigger""")
    input2 = property(_coin.SoTriggerAny_input2_get, _coin.SoTriggerAny_input2_set, doc=r"""input2 : SoSFTrigger""")
    input3 = property(_coin.SoTriggerAny_input3_get, _coin.SoTriggerAny_input3_set, doc=r"""input3 : SoSFTrigger""")
    input4 = property(_coin.SoTriggerAny_input4_get, _coin.SoTriggerAny_input4_set, doc=r"""input4 : SoSFTrigger""")
    input5 = property(_coin.SoTriggerAny_input5_get, _coin.SoTriggerAny_input5_set, doc=r"""input5 : SoSFTrigger""")
    input6 = property(_coin.SoTriggerAny_input6_get, _coin.SoTriggerAny_input6_set, doc=r"""input6 : SoSFTrigger""")
    input7 = property(_coin.SoTriggerAny_input7_get, _coin.SoTriggerAny_input7_set, doc=r"""input7 : SoSFTrigger""")
    input8 = property(_coin.SoTriggerAny_input8_get, _coin.SoTriggerAny_input8_set, doc=r"""input8 : SoSFTrigger""")
    input9 = property(_coin.SoTriggerAny_input9_get, _coin.SoTriggerAny_input9_set, doc=r"""input9 : SoSFTrigger""")
    output = property(_coin.SoTriggerAny_output_get, _coin.SoTriggerAny_output_set, doc=r"""output : SoEngineOutput""")

# Register SoTriggerAny in _coin:
_coin.SoTriggerAny_swigregister(SoTriggerAny)
class SoTexture2Convert(SoEngine):
    r"""Proxy of C++ SoTexture2Convert class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture2Convert_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTexture2Convert self) -> SoType"""
        return _coin.SoTexture2Convert_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoTexture2Convert self) -> SoFieldData"""
        return _coin.SoTexture2Convert_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoTexture2Convert self) -> SoEngineOutputData"""
        return _coin.SoTexture2Convert_getOutputData(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTexture2Convert_initClass()
    sourceImage = property(_coin.SoTexture2Convert_sourceImage_get, _coin.SoTexture2Convert_sourceImage_set, doc=r"""sourceImage : SoSFImage""")
    image = property(_coin.SoTexture2Convert_image_get, _coin.SoTexture2Convert_image_set, doc=r"""image : SoEngineOutput""")
    __swig_destroy__ = _coin.delete_SoTexture2Convert

# Register SoTexture2Convert in _coin:
_coin.SoTexture2Convert_swigregister(SoTexture2Convert)
class SoHeightMapToNormalMap(SoTexture2Convert):
    r"""Proxy of C++ SoHeightMapToNormalMap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoHeightMapToNormalMap_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoHeightMapToNormalMap self) -> SoType"""
        return _coin.SoHeightMapToNormalMap_getTypeId(self)

    def getFieldData(self):
        r"""getFieldData(SoHeightMapToNormalMap self) -> SoFieldData"""
        return _coin.SoHeightMapToNormalMap_getFieldData(self)

    def getOutputData(self):
        r"""getOutputData(SoHeightMapToNormalMap self) -> SoEngineOutputData"""
        return _coin.SoHeightMapToNormalMap_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoHeightMapToNormalMap_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoHeightMapToNormalMap_initClass()

    def __init__(self):
        r"""__init__(SoHeightMapToNormalMap self) -> SoHeightMapToNormalMap"""
        _coin.SoHeightMapToNormalMap_swiginit(self, _coin.new_SoHeightMapToNormalMap())
    INT8 = _coin.SoHeightMapToNormalMap_INT8
    
    format = property(_coin.SoHeightMapToNormalMap_format_get, _coin.SoHeightMapToNormalMap_format_set, doc=r"""format : SoSFEnum""")

    @staticmethod
    def convert(srcptr, size, nc, dst_out):
        r"""convert(unsigned char const * srcptr, SbVec2s size, int nc, SbImage dst_out)"""
        return _coin.SoHeightMapToNormalMap_convert(srcptr, size, nc, dst_out)
    __swig_destroy__ = _coin.delete_SoHeightMapToNormalMap

# Register SoHeightMapToNormalMap in _coin:
_coin.SoHeightMapToNormalMap_swigregister(SoHeightMapToNormalMap)
class SoNodeEngine(SoNode):
    r"""Proxy of C++ SoNodeEngine class."""

    thisown = property(lambda x: 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

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNodeEngine_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNodeEngine_getClassTypeId()

    def evaluateWrapper(self):
        r"""evaluateWrapper(SoNodeEngine self)"""
        return _coin.SoNodeEngine_evaluateWrapper(self)

    def getOutputs(self, l):
        r"""getOutputs(SoNodeEngine self, SoEngineOutputList l) -> int"""
        return _coin.SoNodeEngine_getOutputs(self, l)

    def getOutput(self, outputname):
        r"""getOutput(SoNodeEngine self, SbName outputname) -> SoEngineOutput"""
        return _coin.SoNodeEngine_getOutput(self, outputname)

    def getOutputName(self, output, outputname):
        r"""getOutputName(SoNodeEngine self, SoEngineOutput output, SbName outputname) -> SbBool"""
        return _coin.SoNodeEngine_getOutputName(self, output, outputname)

    def getOutputData(self):
        r"""getOutputData(SoNodeEngine self) -> SoEngineOutputData"""
        return _coin.SoNodeEngine_getOutputData(self)

    def isNotifying(self):
        r"""isNotifying(SoNodeEngine self) -> SbBool"""
        return _coin.SoNodeEngine_isNotifying(self)

    def notify(self, nl):
        r"""notify(SoNodeEngine self, SoNotList nl)"""
        return _coin.SoNodeEngine_notify(self, nl)

    def writeInstance(self, out):
        r"""writeInstance(SoNodeEngine self, SoOutput out)"""
        return _coin.SoNodeEngine_writeInstance(self, out)

# Register SoNodeEngine in _coin:
_coin.SoNodeEngine_swigregister(SoNodeEngine)
class SoMemoryError(SoError):
    r"""Proxy of C++ SoMemoryError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def setHandlerCallback(callback, data):
        r"""setHandlerCallback(SoErrorCB *const callback, void *const data)"""
        return _coin.SoMemoryError_setHandlerCallback(callback, data)

    @staticmethod
    def getHandlerCallback():
        r"""getHandlerCallback() -> SoErrorCB *"""
        return _coin.SoMemoryError_getHandlerCallback()

    @staticmethod
    def getHandlerData():
        r"""getHandlerData() -> void *"""
        return _coin.SoMemoryError_getHandlerData()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMemoryError_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMemoryError self) -> SoType"""
        return _coin.SoMemoryError_getTypeId(self)

    @staticmethod
    def post(whatWasAllocated):
        r"""post(char const *const whatWasAllocated)"""
        return _coin.SoMemoryError_post(whatWasAllocated)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMemoryError_initClass()

    def __init__(self):
        r"""__init__(SoMemoryError self) -> SoMemoryError"""
        _coin.SoMemoryError_swiginit(self, _coin.new_SoMemoryError())
    __swig_destroy__ = _coin.delete_SoMemoryError

# Register SoMemoryError in _coin:
_coin.SoMemoryError_swigregister(SoMemoryError)
class SoReadError(SoError):
    r"""Proxy of C++ SoReadError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def setHandlerCallback(function, data):
        r"""setHandlerCallback(SoErrorCB *const function, void *const data)"""
        return _coin.SoReadError_setHandlerCallback(function, data)

    @staticmethod
    def getHandlerCallback():
        r"""getHandlerCallback() -> SoErrorCB *"""
        return _coin.SoReadError_getHandlerCallback()

    @staticmethod
    def getHandlerData():
        r"""getHandlerData() -> void *"""
        return _coin.SoReadError_getHandlerData()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoReadError_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoReadError self) -> SoType"""
        return _coin.SoReadError_getTypeId(self)

    @staticmethod
    def post(*args):
        r"""post(SoInput input, char const *const format)"""
        return _coin.SoReadError_post(*args)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoReadError_initClass()

    def __init__(self):
        r"""__init__(SoReadError self) -> SoReadError"""
        _coin.SoReadError_swiginit(self, _coin.new_SoReadError())
    __swig_destroy__ = _coin.delete_SoReadError

# Register SoReadError in _coin:
_coin.SoReadError_swigregister(SoReadError)
class SoButtonEvent(SoEvent):
    r"""Proxy of C++ SoButtonEvent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoButtonEvent_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoButtonEvent self) -> SoType"""
        return _coin.SoButtonEvent_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoButtonEvent_initClass()

    def __init__(self):
        r"""__init__(SoButtonEvent self) -> SoButtonEvent"""
        _coin.SoButtonEvent_swiginit(self, _coin.new_SoButtonEvent())
    __swig_destroy__ = _coin.delete_SoButtonEvent
    UP = _coin.SoButtonEvent_UP
    
    DOWN = _coin.SoButtonEvent_DOWN
    
    UNKNOWN = _coin.SoButtonEvent_UNKNOWN
    

    def setState(self, state):
        r"""setState(SoButtonEvent self, SoButtonEvent::State state)"""
        return _coin.SoButtonEvent_setState(self, state)

    def getState(self):
        r"""getState(SoButtonEvent self) -> SoButtonEvent::State"""
        return _coin.SoButtonEvent_getState(self)

    @staticmethod
    def enumToString(enumval, stringrep):
        r"""enumToString(SoButtonEvent::State enumval, SbString stringrep) -> SbBool"""
        return _coin.SoButtonEvent_enumToString(enumval, stringrep)

# Register SoButtonEvent in _coin:
_coin.SoButtonEvent_swigregister(SoButtonEvent)
class SoLocation2Event(SoEvent):
    r"""Proxy of C++ SoLocation2Event class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLocation2Event_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLocation2Event self) -> SoType"""
        return _coin.SoLocation2Event_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLocation2Event_initClass()

    def __init__(self):
        r"""__init__(SoLocation2Event self) -> SoLocation2Event"""
        _coin.SoLocation2Event_swiginit(self, _coin.new_SoLocation2Event())
    __swig_destroy__ = _coin.delete_SoLocation2Event

# Register SoLocation2Event in _coin:
_coin.SoLocation2Event_swigregister(SoLocation2Event)
class SoMotion3Event(SoEvent):
    r"""Proxy of C++ SoMotion3Event class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMotion3Event_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMotion3Event self) -> SoType"""
        return _coin.SoMotion3Event_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMotion3Event_initClass()

    def __init__(self):
        r"""__init__(SoMotion3Event self) -> SoMotion3Event"""
        _coin.SoMotion3Event_swiginit(self, _coin.new_SoMotion3Event())
    __swig_destroy__ = _coin.delete_SoMotion3Event

    def setTranslation(self, t):
        r"""setTranslation(SoMotion3Event self, SbVec3f t)"""
        return _coin.SoMotion3Event_setTranslation(self, t)

    def getTranslation(self):
        r"""getTranslation(SoMotion3Event self) -> SbVec3f"""
        return _coin.SoMotion3Event_getTranslation(self)

    def setRotation(self, r):
        r"""setRotation(SoMotion3Event self, SbRotation r)"""
        return _coin.SoMotion3Event_setRotation(self, r)

    def getRotation(self):
        r"""getRotation(SoMotion3Event self) -> SbRotation"""
        return _coin.SoMotion3Event_getRotation(self)

# Register SoMotion3Event in _coin:
_coin.SoMotion3Event_swigregister(SoMotion3Event)
class SoKeyboardEvent(SoButtonEvent):
    r"""Proxy of C++ SoKeyboardEvent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoKeyboardEvent_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoKeyboardEvent self) -> SoType"""
        return _coin.SoKeyboardEvent_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoKeyboardEvent_initClass()

    def __init__(self):
        r"""__init__(SoKeyboardEvent self) -> SoKeyboardEvent"""
        _coin.SoKeyboardEvent_swiginit(self, _coin.new_SoKeyboardEvent())
    __swig_destroy__ = _coin.delete_SoKeyboardEvent
    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):
        r"""setKey(SoKeyboardEvent self, SoKeyboardEvent::Key key)"""
        return _coin.SoKeyboardEvent_setKey(self, key)

    def getKey(self):
        r"""getKey(SoKeyboardEvent self) -> SoKeyboardEvent::Key"""
        return _coin.SoKeyboardEvent_getKey(self)

    def setPrintableCharacter(self, c):
        r"""setPrintableCharacter(SoKeyboardEvent self, char const c)"""
        return _coin.SoKeyboardEvent_setPrintableCharacter(self, c)

    def getPrintableCharacter(self):
        r"""getPrintableCharacter(SoKeyboardEvent self) -> char"""
        return _coin.SoKeyboardEvent_getPrintableCharacter(self)

    @staticmethod
    def isKeyPressEvent(e, whichKey):
        r"""isKeyPressEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
        return _coin.SoKeyboardEvent_isKeyPressEvent(e, whichKey)

    @staticmethod
    def isKeyReleaseEvent(e, whichKey):
        r"""isKeyReleaseEvent(SoEvent e, SoKeyboardEvent::Key whichKey) -> SbBool"""
        return _coin.SoKeyboardEvent_isKeyReleaseEvent(e, whichKey)

    @staticmethod
    def enumToString(enumval, stringrep):
        r"""enumToString(SoKeyboardEvent::Key enumval, SbString stringrep) -> SbBool"""
        return _coin.SoKeyboardEvent_enumToString(enumval, stringrep)

# Register SoKeyboardEvent in _coin:
_coin.SoKeyboardEvent_swigregister(SoKeyboardEvent)
class SoMouseButtonEvent(SoButtonEvent):
    r"""Proxy of C++ SoMouseButtonEvent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMouseButtonEvent_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMouseButtonEvent self) -> SoType"""
        return _coin.SoMouseButtonEvent_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMouseButtonEvent_initClass()

    def __init__(self):
        r"""__init__(SoMouseButtonEvent self) -> SoMouseButtonEvent"""
        _coin.SoMouseButtonEvent_swiginit(self, _coin.new_SoMouseButtonEvent())
    __swig_destroy__ = _coin.delete_SoMouseButtonEvent
    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):
        r"""setButton(SoMouseButtonEvent self, SoMouseButtonEvent::Button button)"""
        return _coin.SoMouseButtonEvent_setButton(self, button)

    def getButton(self):
        r"""getButton(SoMouseButtonEvent self) -> SoMouseButtonEvent::Button"""
        return _coin.SoMouseButtonEvent_getButton(self)

    @staticmethod
    def isButtonPressEvent(e, whichButton):
        r"""isButtonPressEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoMouseButtonEvent_isButtonPressEvent(e, whichButton)

    @staticmethod
    def isButtonReleaseEvent(e, whichButton):
        r"""isButtonReleaseEvent(SoEvent e, SoMouseButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoMouseButtonEvent_isButtonReleaseEvent(e, whichButton)

    @staticmethod
    def enumToString(enumval, stringrep):
        r"""enumToString(SoMouseButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
        return _coin.SoMouseButtonEvent_enumToString(enumval, stringrep)

# Register SoMouseButtonEvent in _coin:
_coin.SoMouseButtonEvent_swigregister(SoMouseButtonEvent)
class SoSpaceballButtonEvent(SoButtonEvent):
    r"""Proxy of C++ SoSpaceballButtonEvent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpaceballButtonEvent_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSpaceballButtonEvent self) -> SoType"""
        return _coin.SoSpaceballButtonEvent_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSpaceballButtonEvent_initClass()

    def __init__(self):
        r"""__init__(SoSpaceballButtonEvent self) -> SoSpaceballButtonEvent"""
        _coin.SoSpaceballButtonEvent_swiginit(self, _coin.new_SoSpaceballButtonEvent())
    __swig_destroy__ = _coin.delete_SoSpaceballButtonEvent
    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):
        r"""setButton(SoSpaceballButtonEvent self, SoSpaceballButtonEvent::Button button)"""
        return _coin.SoSpaceballButtonEvent_setButton(self, button)

    def getButton(self):
        r"""getButton(SoSpaceballButtonEvent self) -> SoSpaceballButtonEvent::Button"""
        return _coin.SoSpaceballButtonEvent_getButton(self)

    @staticmethod
    def isButtonPressEvent(e, whichButton):
        r"""isButtonPressEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_isButtonPressEvent(e, whichButton)

    @staticmethod
    def isButtonReleaseEvent(e, whichButton):
        r"""isButtonReleaseEvent(SoEvent e, SoSpaceballButtonEvent::Button whichButton) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_isButtonReleaseEvent(e, whichButton)

    @staticmethod
    def enumToString(enumval, stringrep):
        r"""enumToString(SoSpaceballButtonEvent::Button enumval, SbString stringrep) -> SbBool"""
        return _coin.SoSpaceballButtonEvent_enumToString(enumval, stringrep)

# Register SoSpaceballButtonEvent in _coin:
_coin.SoSpaceballButtonEvent_swigregister(SoSpaceballButtonEvent)
class SbBox2s(object):
    r"""Proxy of C++ SbBox2s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbBox2s_swiginit(self, _coin.new_SbBox2s(*args))

    def setBounds(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        getMin(SbBox2s self) -> SbVec2s
        getMin(SbBox2s self) -> SbVec2s
        """
        return _coin.SbBox2s_getMin(self, *args)

    def getMax(self, *args):
        r"""
        getMax(SbBox2s self) -> SbVec2s
        getMax(SbBox2s self) -> SbVec2s
        """
        return _coin.SbBox2s_getMax(self, *args)

    def extendBy(self, *args):
        r"""
        extendBy(SbBox2s self, SbVec2s point)
        extendBy(SbBox2s self, SbBox2s box)
        """
        return _coin.SbBox2s_extendBy(self, *args)

    def makeEmpty(self):
        r"""makeEmpty(SbBox2s self)"""
        return _coin.SbBox2s_makeEmpty(self)

    def isEmpty(self):
        r"""isEmpty(SbBox2s self) -> SbBool"""
        return _coin.SbBox2s_isEmpty(self)

    def hasArea(self):
        r"""hasArea(SbBox2s self) -> SbBool"""
        return _coin.SbBox2s_hasArea(self)

    def intersect(self, *args):
        r"""
        intersect(SbBox2s self, SbVec2s point) -> SbBool
        intersect(SbBox2s self, SbBox2s box) -> SbBool
        """
        return _coin.SbBox2s_intersect(self, *args)

    def getCenter(self):
        r"""getCenter(SbBox2s self) -> SbVec2f"""
        return _coin.SbBox2s_getCenter(self)

    def getOrigin(self, originX, originY):
        r"""getOrigin(SbBox2s self, short & originX, short & originY)"""
        return _coin.SbBox2s_getOrigin(self, originX, originY)

    def getSize(self, sizeX, sizeY):
        r"""getSize(SbBox2s self, short & sizeX, short & sizeY)"""
        return _coin.SbBox2s_getSize(self, sizeX, sizeY)

    def getAspectRatio(self):
        r"""getAspectRatio(SbBox2s self) -> float"""
        return _coin.SbBox2s_getAspectRatio(self)

    def __eq__(self, u):
        r"""__eq__(SbBox2s self, SbBox2s u) -> int"""
        return _coin.SbBox2s___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbBox2s self, SbBox2s u) -> int"""
        return _coin.SbBox2s___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbBox2s

# Register SbBox2s in _coin:
_coin.SbBox2s_swigregister(SbBox2s)
class SoSFBox2s(SoSField):
    r"""Proxy of C++ SoSFBox2s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBox2s self) -> SoSFBox2s"""
        _coin.SoSFBox2s_swiginit(self, _coin.new_SoSFBox2s())
    __swig_destroy__ = _coin.delete_SoSFBox2s

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBox2s_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox2s_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBox2s self) -> SoType"""
        return _coin.SoSFBox2s_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBox2s self, SoField field)"""
        return _coin.SoSFBox2s_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBox2s self, SoField field) -> SbBool"""
        return _coin.SoSFBox2s_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFBox2s self, SoSFBox2s field) -> int"""
        return _coin.SoSFBox2s___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBox2s self, SoSFBox2s field) -> int"""
        return _coin.SoSFBox2s___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBox2s_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SoSFBox2s self) -> SbBox2s
        getValue(SoSFBox2s self, SbBox2s box)
        """
        return _coin.SoSFBox2s_getValue(self, *args)

# Register SoSFBox2s in _coin:
_coin.SoSFBox2s_swigregister(SoSFBox2s)
class SbVec2i32(object):
    r"""Proxy of C++ SbVec2i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec2i32_swiginit(self, _coin.new_SbVec2i32(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec2i32 self, SbVec2i32 v) -> int32_t"""
        return _coin.SbVec2i32_dot(self, v)

    def negate(self):
        r"""negate(SbVec2i32 self)"""
        return _coin.SbVec2i32_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec2i32 self, int d) -> SbVec2i32
        __imul__(SbVec2i32 self, double d) -> SbVec2i32
        """
        return _coin.SbVec2i32___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec2i32___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec2i32 self, SbVec2i32 v) -> SbVec2i32"""
        return _coin.SbVec2i32___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec2i32 self, SbVec2i32 v) -> SbVec2i32"""
        return _coin.SbVec2i32___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec2i32 self) -> SbVec2i32"""
        return _coin.SbVec2i32___neg__(self)

    def output(self, fp):
        r"""output(SbVec2i32 self, FILE * fp)"""
        return _coin.SbVec2i32_output(self, fp)
    __swig_destroy__ = _coin.delete_SbVec2i32

# Register SbVec2i32 in _coin:
_coin.SbVec2i32_swigregister(SbVec2i32)
class SbBox2i32(object):
    r"""Proxy of C++ SbBox2i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbBox2i32_swiginit(self, _coin.new_SbBox2i32(*args))

    def setBounds(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        getMin(SbBox2i32 self) -> SbVec2i32
        getMin(SbBox2i32 self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getMin(self, *args)

    def getMax(self, *args):
        r"""
        getMax(SbBox2i32 self) -> SbVec2i32
        getMax(SbBox2i32 self) -> SbVec2i32
        """
        return _coin.SbBox2i32_getMax(self, *args)

    def extendBy(self, *args):
        r"""
        extendBy(SbBox2i32 self, SbVec2i32 point)
        extendBy(SbBox2i32 self, SbBox2i32 box)
        """
        return _coin.SbBox2i32_extendBy(self, *args)

    def makeEmpty(self):
        r"""makeEmpty(SbBox2i32 self)"""
        return _coin.SbBox2i32_makeEmpty(self)

    def isEmpty(self):
        r"""isEmpty(SbBox2i32 self) -> SbBool"""
        return _coin.SbBox2i32_isEmpty(self)

    def hasArea(self):
        r"""hasArea(SbBox2i32 self) -> SbBool"""
        return _coin.SbBox2i32_hasArea(self)

    def intersect(self, *args):
        r"""
        intersect(SbBox2i32 self, SbVec2i32 point) -> SbBool
        intersect(SbBox2i32 self, SbBox2i32 box) -> SbBool
        """
        return _coin.SbBox2i32_intersect(self, *args)

    def getCenter(self):
        r"""getCenter(SbBox2i32 self) -> SbVec2f"""
        return _coin.SbBox2i32_getCenter(self)

    def getOrigin(self, originX, originY):
        r"""getOrigin(SbBox2i32 self, int32_t & originX, int32_t & originY)"""
        return _coin.SbBox2i32_getOrigin(self, originX, originY)

    def getSize(self, sizeX, sizeY):
        r"""getSize(SbBox2i32 self, int32_t & sizeX, int32_t & sizeY)"""
        return _coin.SbBox2i32_getSize(self, sizeX, sizeY)

    def getAspectRatio(self):
        r"""getAspectRatio(SbBox2i32 self) -> float"""
        return _coin.SbBox2i32_getAspectRatio(self)
    __swig_destroy__ = _coin.delete_SbBox2i32

# Register SbBox2i32 in _coin:
_coin.SbBox2i32_swigregister(SbBox2i32)
class SoSFBox2i32(SoSField):
    r"""Proxy of C++ SoSFBox2i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBox2i32 self) -> SoSFBox2i32"""
        _coin.SoSFBox2i32_swiginit(self, _coin.new_SoSFBox2i32())
    __swig_destroy__ = _coin.delete_SoSFBox2i32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBox2i32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox2i32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBox2i32 self) -> SoType"""
        return _coin.SoSFBox2i32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBox2i32 self, SoField field)"""
        return _coin.SoSFBox2i32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBox2i32 self, SoField field) -> SbBool"""
        return _coin.SoSFBox2i32_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFBox2i32 self, SoSFBox2i32 field) -> int"""
        return _coin.SoSFBox2i32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBox2i32 self, SoSFBox2i32 field) -> int"""
        return _coin.SoSFBox2i32___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBox2i32_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SoSFBox2i32 self) -> SbBox2i32
        getValue(SoSFBox2i32 self, SbBox2i32 box)
        """
        return _coin.SoSFBox2i32_getValue(self, *args)

# Register SoSFBox2i32 in _coin:
_coin.SoSFBox2i32_swigregister(SoSFBox2i32)
class SbBox2f(object):
    r"""Proxy of C++ SbBox2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbBox2f_swiginit(self, _coin.new_SbBox2f(*args))

    def setBounds(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        getMin(SbBox2f self) -> SbVec2f
        getMin(SbBox2f self) -> SbVec2f
        """
        return _coin.SbBox2f_getMin(self, *args)

    def getMax(self, *args):
        r"""
        getMax(SbBox2f self) -> SbVec2f
        getMax(SbBox2f self) -> SbVec2f
        """
        return _coin.SbBox2f_getMax(self, *args)

    def extendBy(self, *args):
        r"""
        extendBy(SbBox2f self, SbVec2f point)
        extendBy(SbBox2f self, SbBox2f box)
        """
        return _coin.SbBox2f_extendBy(self, *args)

    def makeEmpty(self):
        r"""makeEmpty(SbBox2f self)"""
        return _coin.SbBox2f_makeEmpty(self)

    def isEmpty(self):
        r"""isEmpty(SbBox2f self) -> SbBool"""
        return _coin.SbBox2f_isEmpty(self)

    def hasArea(self):
        r"""hasArea(SbBox2f self) -> SbBool"""
        return _coin.SbBox2f_hasArea(self)

    def intersect(self, *args):
        r"""
        intersect(SbBox2f self, SbVec2f point) -> SbBool
        intersect(SbBox2f self, SbBox2f box) -> SbBool
        """
        return _coin.SbBox2f_intersect(self, *args)

    def getClosestPoint(self, point):
        r"""getClosestPoint(SbBox2f self, SbVec2f point) -> SbVec2f"""
        return _coin.SbBox2f_getClosestPoint(self, point)

    def getCenter(self):
        r"""getCenter(SbBox2f self) -> SbVec2f"""
        return _coin.SbBox2f_getCenter(self)

    def getOrigin(self, originX, originY):
        r"""getOrigin(SbBox2f self, float & originX, float & originY)"""
        return _coin.SbBox2f_getOrigin(self, originX, originY)

    def getSize(self, sizeX, sizeY):
        r"""getSize(SbBox2f self, float & sizeX, float & sizeY)"""
        return _coin.SbBox2f_getSize(self, sizeX, sizeY)

    def getAspectRatio(self):
        r"""getAspectRatio(SbBox2f self) -> float"""
        return _coin.SbBox2f_getAspectRatio(self)

    def __eq__(self, u):
        r"""__eq__(SbBox2f self, SbBox2f u) -> int"""
        return _coin.SbBox2f___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbBox2f self, SbBox2f u) -> int"""
        return _coin.SbBox2f___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbBox2f

# Register SbBox2f in _coin:
_coin.SbBox2f_swigregister(SbBox2f)
class SoSFBox2f(SoSField):
    r"""Proxy of C++ SoSFBox2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBox2f self) -> SoSFBox2f"""
        _coin.SoSFBox2f_swiginit(self, _coin.new_SoSFBox2f())
    __swig_destroy__ = _coin.delete_SoSFBox2f

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBox2f_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox2f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBox2f self) -> SoType"""
        return _coin.SoSFBox2f_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBox2f self, SoField field)"""
        return _coin.SoSFBox2f_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBox2f self, SoField field) -> SbBool"""
        return _coin.SoSFBox2f_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFBox2f self, SoSFBox2f field) -> int"""
        return _coin.SoSFBox2f___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBox2f self, SoSFBox2f field) -> int"""
        return _coin.SoSFBox2f___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBox2f_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SoSFBox2f self) -> SbBox2f
        getValue(SoSFBox2f self, SbBox2f box)
        """
        return _coin.SoSFBox2f_getValue(self, *args)

# Register SoSFBox2f in _coin:
_coin.SoSFBox2f_swigregister(SoSFBox2f)
class SbVec2d(object):
    r"""Proxy of C++ SbVec2d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec2d_swiginit(self, _coin.new_SbVec2d(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""getValue(SbVec2d self)"""
        return _coin.SbVec2d_getValue(self)

    def equals(self, v, tolerance):
        r"""equals(SbVec2d self, SbVec2d v, double tolerance) -> SbBool"""
        return _coin.SbVec2d_equals(self, v, tolerance)

    def dot(self, v):
        r"""dot(SbVec2d self, SbVec2d v) -> double"""
        return _coin.SbVec2d_dot(self, v)

    def length(self):
        r"""length(SbVec2d self) -> double"""
        return _coin.SbVec2d_length(self)

    def sqrLength(self):
        r"""sqrLength(SbVec2d self) -> double"""
        return _coin.SbVec2d_sqrLength(self)

    def normalize(self):
        r"""normalize(SbVec2d self) -> double"""
        return _coin.SbVec2d_normalize(self)

    def negate(self):
        r"""negate(SbVec2d self)"""
        return _coin.SbVec2d_negate(self)

    def __imul__(self, d):
        r"""__imul__(SbVec2d self, double d) -> SbVec2d"""
        return _coin.SbVec2d___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec2d___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec2d self, SbVec2d v) -> SbVec2d"""
        return _coin.SbVec2d___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec2d self, SbVec2d v) -> SbVec2d"""
        return _coin.SbVec2d___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec2d self) -> SbVec2d"""
        return _coin.SbVec2d___neg__(self)

    def output(self, fp):
        r"""output(SbVec2d self, FILE * fp)"""
        return _coin.SbVec2d_output(self, fp)

    def __add__(self, u):
        r"""__add__(SbVec2d self, SbVec2d u) -> SbVec2d"""
        return _coin.SbVec2d___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbVec2d self, SbVec2d u) -> SbVec2d"""
        return _coin.SbVec2d___sub__(self, u)

    def __mul__(self, d):
        r"""__mul__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___mul__(self, d)

    def __rmul__(self, d):
        r"""__rmul__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___div__(self, d)

    def __truediv__(self, d):
        r"""__truediv__(SbVec2d self, float const d) -> SbVec2d"""
        return _coin.SbVec2d___truediv__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbVec2d self, SbVec2d u) -> int"""
        return _coin.SbVec2d___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbVec2d self, SbVec2d u) -> int"""
        return _coin.SbVec2d___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbVec2d self, int i) -> double"""
        return _coin.SbVec2d___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__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

# Register SbVec2d in _coin:
_coin.SbVec2d_swigregister(SbVec2d)
class SbBox2d(object):
    r"""Proxy of C++ SbBox2d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbBox2d_swiginit(self, _coin.new_SbBox2d(*args))

    def setBounds(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        getMin(SbBox2d self) -> SbVec2d
        getMin(SbBox2d self) -> SbVec2d
        """
        return _coin.SbBox2d_getMin(self, *args)

    def getMax(self, *args):
        r"""
        getMax(SbBox2d self) -> SbVec2d
        getMax(SbBox2d self) -> SbVec2d
        """
        return _coin.SbBox2d_getMax(self, *args)

    def extendBy(self, *args):
        r"""
        extendBy(SbBox2d self, SbVec2d point)
        extendBy(SbBox2d self, SbBox2d box)
        """
        return _coin.SbBox2d_extendBy(self, *args)

    def makeEmpty(self):
        r"""makeEmpty(SbBox2d self)"""
        return _coin.SbBox2d_makeEmpty(self)

    def isEmpty(self):
        r"""isEmpty(SbBox2d self) -> SbBool"""
        return _coin.SbBox2d_isEmpty(self)

    def hasArea(self):
        r"""hasArea(SbBox2d self) -> SbBool"""
        return _coin.SbBox2d_hasArea(self)

    def intersect(self, *args):
        r"""
        intersect(SbBox2d self, SbVec2d point) -> SbBool
        intersect(SbBox2d self, SbBox2d box) -> SbBool
        """
        return _coin.SbBox2d_intersect(self, *args)

    def getClosestPoint(self, p):
        r"""getClosestPoint(SbBox2d self, SbVec2d p) -> SbVec2d"""
        return _coin.SbBox2d_getClosestPoint(self, p)

    def findIntersection(self, a, b, ia, ib):
        r"""findIntersection(SbBox2d self, SbVec2d a, SbVec2d b, SbVec2d ia, SbVec2d ib) -> SbBool"""
        return _coin.SbBox2d_findIntersection(self, a, b, ia, ib)

    def getCenter(self):
        r"""getCenter(SbBox2d self) -> SbVec2d"""
        return _coin.SbBox2d_getCenter(self)

    def getOrigin(self, originX, originY):
        r"""getOrigin(SbBox2d self, double & originX, double & originY)"""
        return _coin.SbBox2d_getOrigin(self, originX, originY)

    def getSize(self, sizeX, sizeY):
        r"""getSize(SbBox2d self, double & sizeX, double & sizeY)"""
        return _coin.SbBox2d_getSize(self, sizeX, sizeY)

    def getAspectRatio(self):
        r"""getAspectRatio(SbBox2d self) -> double"""
        return _coin.SbBox2d_getAspectRatio(self)

    def __eq__(self, u):
        r"""__eq__(SbBox2d self, SbBox2d u) -> int"""
        return _coin.SbBox2d___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbBox2d self, SbBox2d u) -> int"""
        return _coin.SbBox2d___ne__(self, u)

    def setValue(self, u):
        r"""setValue(SbBox2d self, SbBox2d u) -> SbBox2d"""
        return _coin.SbBox2d_setValue(self, u)
    __swig_destroy__ = _coin.delete_SbBox2d

# Register SbBox2d in _coin:
_coin.SbBox2d_swigregister(SbBox2d)
class SoSFBox2d(SoSField):
    r"""Proxy of C++ SoSFBox2d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBox2d self) -> SoSFBox2d"""
        _coin.SoSFBox2d_swiginit(self, _coin.new_SoSFBox2d())
    __swig_destroy__ = _coin.delete_SoSFBox2d

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBox2d_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox2d_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBox2d self) -> SoType"""
        return _coin.SoSFBox2d_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBox2d self, SoField field)"""
        return _coin.SoSFBox2d_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBox2d self, SoField field) -> SbBool"""
        return _coin.SoSFBox2d_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFBox2d self, SoSFBox2d field) -> int"""
        return _coin.SoSFBox2d___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBox2d self, SoSFBox2d field) -> int"""
        return _coin.SoSFBox2d___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBox2d_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SoSFBox2d self) -> SbBox2d
        getValue(SoSFBox2d self, SbBox2d box)
        """
        return _coin.SoSFBox2d_getValue(self, *args)

# Register SoSFBox2d in _coin:
_coin.SoSFBox2d_swigregister(SoSFBox2d)
class SbBox3s(object):
    r"""Proxy of C++ SbBox3s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbBox3s_swiginit(self, _coin.new_SbBox3s(*args))

    def setBounds(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        getMin(SbBox3s self) -> SbVec3s
        getMin(SbBox3s self) -> SbVec3s
        """
        return _coin.SbBox3s_getMin(self, *args)

    def getMax(self, *args):
        r"""
        getMax(SbBox3s self) -> SbVec3s
        getMax(SbBox3s self) -> SbVec3s
        """
        return _coin.SbBox3s_getMax(self, *args)

    def extendBy(self, *args):
        r"""
        extendBy(SbBox3s self, SbVec3s pt)
        extendBy(SbBox3s self, SbBox3s box)
        """
        return _coin.SbBox3s_extendBy(self, *args)

    def makeEmpty(self):
        r"""makeEmpty(SbBox3s self)"""
        return _coin.SbBox3s_makeEmpty(self)

    def isEmpty(self):
        r"""isEmpty(SbBox3s self) -> SbBool"""
        return _coin.SbBox3s_isEmpty(self)

    def hasVolume(self):
        r"""hasVolume(SbBox3s self) -> SbBool"""
        return _coin.SbBox3s_hasVolume(self)

    def getVolume(self):
        r"""getVolume(SbBox3s self) -> int"""
        return _coin.SbBox3s_getVolume(self)

    def intersect(self, *args):
        r"""
        intersect(SbBox3s self, SbVec3s pt) -> SbBool
        intersect(SbBox3s self, SbBox3s box) -> SbBool
        """
        return _coin.SbBox3s_intersect(self, *args)

    def getClosestPoint(self, pt):
        r"""getClosestPoint(SbBox3s self, SbVec3f pt) -> SbVec3f"""
        return _coin.SbBox3s_getClosestPoint(self, pt)

    def getCenter(self):
        r"""getCenter(SbBox3s self) -> SbVec3f"""
        return _coin.SbBox3s_getCenter(self)

    def getOrigin(self, originX, originY, originZ):
        r"""getOrigin(SbBox3s self, short & originX, short & originY, short & originZ)"""
        return _coin.SbBox3s_getOrigin(self, originX, originY, originZ)

    def getSize(self, sizeX, sizeY, sizeZ):
        r"""getSize(SbBox3s self, short & sizeX, short & sizeY, short & sizeZ)"""
        return _coin.SbBox3s_getSize(self, sizeX, sizeY, sizeZ)

    def __eq__(self, u):
        r"""__eq__(SbBox3s self, SbBox3s u) -> int"""
        return _coin.SbBox3s___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbBox3s self, SbBox3s u) -> int"""
        return _coin.SbBox3s___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbBox3s

# Register SbBox3s in _coin:
_coin.SbBox3s_swigregister(SbBox3s)
class SoSFBox3s(SoSField):
    r"""Proxy of C++ SoSFBox3s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBox3s self) -> SoSFBox3s"""
        _coin.SoSFBox3s_swiginit(self, _coin.new_SoSFBox3s())
    __swig_destroy__ = _coin.delete_SoSFBox3s

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBox3s_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox3s_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBox3s self) -> SoType"""
        return _coin.SoSFBox3s_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBox3s self, SoField field)"""
        return _coin.SoSFBox3s_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBox3s self, SoField field) -> SbBool"""
        return _coin.SoSFBox3s_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFBox3s self, SoSFBox3s field) -> int"""
        return _coin.SoSFBox3s___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBox3s self, SoSFBox3s field) -> int"""
        return _coin.SoSFBox3s___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBox3s_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SoSFBox3s self) -> SbBox3s
        getValue(SoSFBox3s self, SbBox3s box)
        """
        return _coin.SoSFBox3s_getValue(self, *args)

# Register SoSFBox3s in _coin:
_coin.SoSFBox3s_swigregister(SoSFBox3s)
class SbVec3i32(object):
    r"""Proxy of C++ SbVec3i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec3i32_swiginit(self, _coin.new_SbVec3i32(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec3i32 self, SbVec3i32 v) -> int32_t"""
        return _coin.SbVec3i32_dot(self, v)

    def negate(self):
        r"""negate(SbVec3i32 self)"""
        return _coin.SbVec3i32_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec3i32 self, int d) -> SbVec3i32
        __imul__(SbVec3i32 self, double d) -> SbVec3i32
        """
        return _coin.SbVec3i32___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec3i32___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec3i32 self, SbVec3i32 v) -> SbVec3i32"""
        return _coin.SbVec3i32___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec3i32 self, SbVec3i32 v) -> SbVec3i32"""
        return _coin.SbVec3i32___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec3i32 self) -> SbVec3i32"""
        return _coin.SbVec3i32___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec3i32

# Register SbVec3i32 in _coin:
_coin.SbVec3i32_swigregister(SbVec3i32)
class SbBox3i32(object):
    r"""Proxy of C++ SbBox3i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbBox3i32_swiginit(self, _coin.new_SbBox3i32(*args))

    def setBounds(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        getMin(SbBox3i32 self) -> SbVec3i32
        getMin(SbBox3i32 self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getMin(self, *args)

    def getMax(self, *args):
        r"""
        getMax(SbBox3i32 self) -> SbVec3i32
        getMax(SbBox3i32 self) -> SbVec3i32
        """
        return _coin.SbBox3i32_getMax(self, *args)

    def extendBy(self, *args):
        r"""
        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):
        r"""transform(SbBox3i32 self, SbMatrix m)"""
        return _coin.SbBox3i32_transform(self, m)

    def makeEmpty(self):
        r"""makeEmpty(SbBox3i32 self)"""
        return _coin.SbBox3i32_makeEmpty(self)

    def isEmpty(self):
        r"""isEmpty(SbBox3i32 self) -> SbBool"""
        return _coin.SbBox3i32_isEmpty(self)

    def hasVolume(self):
        r"""hasVolume(SbBox3i32 self) -> SbBool"""
        return _coin.SbBox3i32_hasVolume(self)

    def getVolume(self):
        r"""getVolume(SbBox3i32 self) -> float"""
        return _coin.SbBox3i32_getVolume(self)

    def intersect(self, *args):
        r"""
        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):
        r"""outside(SbBox3i32 self, SbMatrix MVP, int & cullBits) -> SbBool"""
        return _coin.SbBox3i32_outside(self, MVP, cullBits)

    def getClosestPoint(self, pt):
        r"""getClosestPoint(SbBox3i32 self, SbVec3f pt) -> SbVec3f"""
        return _coin.SbBox3i32_getClosestPoint(self, pt)

    def getCenter(self):
        r"""getCenter(SbBox3i32 self) -> SbVec3f"""
        return _coin.SbBox3i32_getCenter(self)

    def getOrigin(self, originX, originY, originZ):
        r"""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):
        r"""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):
        r"""getSpan(SbBox3i32 self, SbVec3f direction, float & dmin, float & dmax)"""
        return _coin.SbBox3i32_getSpan(self, direction, dmin, dmax)
    __swig_destroy__ = _coin.delete_SbBox3i32

# Register SbBox3i32 in _coin:
_coin.SbBox3i32_swigregister(SbBox3i32)
class SoSFBox3i32(SoSField):
    r"""Proxy of C++ SoSFBox3i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBox3i32 self) -> SoSFBox3i32"""
        _coin.SoSFBox3i32_swiginit(self, _coin.new_SoSFBox3i32())
    __swig_destroy__ = _coin.delete_SoSFBox3i32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBox3i32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox3i32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBox3i32 self) -> SoType"""
        return _coin.SoSFBox3i32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBox3i32 self, SoField field)"""
        return _coin.SoSFBox3i32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBox3i32 self, SoField field) -> SbBool"""
        return _coin.SoSFBox3i32_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFBox3i32 self, SoSFBox3i32 field) -> int"""
        return _coin.SoSFBox3i32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBox3i32 self, SoSFBox3i32 field) -> int"""
        return _coin.SoSFBox3i32___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBox3i32_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SoSFBox3i32 self) -> SbBox3i32
        getValue(SoSFBox3i32 self, SbBox3i32 box)
        """
        return _coin.SoSFBox3i32_getValue(self, *args)

# Register SoSFBox3i32 in _coin:
_coin.SoSFBox3i32_swigregister(SoSFBox3i32)
class SoSFBox3f(SoSField):
    r"""Proxy of C++ SoSFBox3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBox3f self) -> SoSFBox3f"""
        _coin.SoSFBox3f_swiginit(self, _coin.new_SoSFBox3f())
    __swig_destroy__ = _coin.delete_SoSFBox3f

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBox3f_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBox3f self) -> SoType"""
        return _coin.SoSFBox3f_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBox3f self, SoField field)"""
        return _coin.SoSFBox3f_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBox3f self, SoField field) -> SbBool"""
        return _coin.SoSFBox3f_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFBox3f self, SoSFBox3f field) -> int"""
        return _coin.SoSFBox3f___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBox3f self, SoSFBox3f field) -> int"""
        return _coin.SoSFBox3f___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBox3f_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SoSFBox3f self) -> SbBox3f
        getValue(SoSFBox3f self, SbBox3f box)
        """
        return _coin.SoSFBox3f_getValue(self, *args)

# Register SoSFBox3f in _coin:
_coin.SoSFBox3f_swigregister(SoSFBox3f)
class SbBox3d(object):
    r"""Proxy of C++ SbBox3d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbBox3d_swiginit(self, _coin.new_SbBox3d(*args))

    def setBounds(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        getMin(SbBox3d self) -> SbVec3d
        getMin(SbBox3d self) -> SbVec3d
        """
        return _coin.SbBox3d_getMin(self, *args)

    def getMax(self, *args):
        r"""
        getMax(SbBox3d self) -> SbVec3d
        getMax(SbBox3d self) -> SbVec3d
        """
        return _coin.SbBox3d_getMax(self, *args)

    def extendBy(self, *args):
        r"""
        extendBy(SbBox3d self, SbVec3d pt)
        extendBy(SbBox3d self, SbBox3d box)
        """
        return _coin.SbBox3d_extendBy(self, *args)

    def transform(self, matrix):
        r"""transform(SbBox3d self, SbDPMatrix matrix)"""
        return _coin.SbBox3d_transform(self, matrix)

    def makeEmpty(self):
        r"""makeEmpty(SbBox3d self)"""
        return _coin.SbBox3d_makeEmpty(self)

    def isEmpty(self):
        r"""isEmpty(SbBox3d self) -> SbBool"""
        return _coin.SbBox3d_isEmpty(self)

    def hasVolume(self):
        r"""hasVolume(SbBox3d self) -> SbBool"""
        return _coin.SbBox3d_hasVolume(self)

    def getVolume(self):
        r"""getVolume(SbBox3d self) -> double"""
        return _coin.SbBox3d_getVolume(self)

    def intersect(self, *args):
        r"""
        intersect(SbBox3d self, SbVec3d point) -> SbBool
        intersect(SbBox3d self, SbBox3d box) -> SbBool
        """
        return _coin.SbBox3d_intersect(self, *args)

    def getClosestPoint(self, point):
        r"""getClosestPoint(SbBox3d self, SbVec3d point) -> SbVec3d"""
        return _coin.SbBox3d_getClosestPoint(self, point)

    def outside(self, mvp, cullbits):
        r"""outside(SbBox3d self, SbDPMatrix mvp, int & cullbits) -> SbBool"""
        return _coin.SbBox3d_outside(self, mvp, cullbits)

    def getCenter(self):
        r"""getCenter(SbBox3d self) -> SbVec3d"""
        return _coin.SbBox3d_getCenter(self)

    def getOrigin(self, origoX, origoY, origoZ):
        r"""getOrigin(SbBox3d self, double & origoX, double & origoY, double & origoZ)"""
        return _coin.SbBox3d_getOrigin(self, origoX, origoY, origoZ)

    def getSize(self, *args):
        r"""
        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):
        r"""getSpan(SbBox3d self, SbVec3d dir, double & dmin, double & dmax)"""
        return _coin.SbBox3d_getSpan(self, dir, dmin, dmax)

    def output(self, file):
        r"""output(SbBox3d self, FILE * file)"""
        return _coin.SbBox3d_output(self, file)
    __swig_destroy__ = _coin.delete_SbBox3d

# Register SbBox3d in _coin:
_coin.SbBox3d_swigregister(SbBox3d)
class SoSFBox3d(SoSField):
    r"""Proxy of C++ SoSFBox3d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFBox3d self) -> SoSFBox3d"""
        _coin.SoSFBox3d_swiginit(self, _coin.new_SoSFBox3d())
    __swig_destroy__ = _coin.delete_SoSFBox3d

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFBox3d_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFBox3d_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFBox3d self) -> SoType"""
        return _coin.SoSFBox3d_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFBox3d self, SoField field)"""
        return _coin.SoSFBox3d_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFBox3d self, SoField field) -> SbBool"""
        return _coin.SoSFBox3d_isSame(self, field)

    def __eq__(self, field):
        r"""__eq__(SoSFBox3d self, SoSFBox3d field) -> int"""
        return _coin.SoSFBox3d___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFBox3d self, SoSFBox3d field) -> int"""
        return _coin.SoSFBox3d___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFBox3d_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SoSFBox3d self) -> SbBox3d
        getValue(SoSFBox3d self, SbBox3d box)
        """
        return _coin.SoSFBox3d_getValue(self, *args)

# Register SoSFBox3d in _coin:
_coin.SoSFBox3d_swigregister(SoSFBox3d)
class SoSFColorRGBA(SoSField):
    r"""Proxy of C++ SoSFColorRGBA class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFColorRGBA self) -> SoSFColorRGBA"""
        _coin.SoSFColorRGBA_swiginit(self, _coin.new_SoSFColorRGBA())
    __swig_destroy__ = _coin.delete_SoSFColorRGBA

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFColorRGBA_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFColorRGBA_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFColorRGBA self) -> SoType"""
        return _coin.SoSFColorRGBA_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFColorRGBA self, SoField field)"""
        return _coin.SoSFColorRGBA_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFColorRGBA self, SoField field) -> SbBool"""
        return _coin.SoSFColorRGBA_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFColorRGBA self) -> SbColor4f"""
        return _coin.SoSFColorRGBA_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFColorRGBA self, SoSFColorRGBA field) -> int"""
        return _coin.SoSFColorRGBA___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFColorRGBA self, SoSFColorRGBA field) -> int"""
        return _coin.SoSFColorRGBA___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFColorRGBA_initClass()

    def setValue(self, *args):
        r"""
        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):
        r"""
        setHSVValue(SoSFColorRGBA self, float h, float s, float v, float a)
        setHSVValue(SoSFColorRGBA self, float const [4] hsva)
        """
        return _coin.SoSFColorRGBA_setHSVValue(self, *args)

# Register SoSFColorRGBA in _coin:
_coin.SoSFColorRGBA_swigregister(SoSFColorRGBA)
class SoSFDouble(SoSField):
    r"""Proxy of C++ SoSFDouble class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFDouble self) -> SoSFDouble"""
        _coin.SoSFDouble_swiginit(self, _coin.new_SoSFDouble())
    __swig_destroy__ = _coin.delete_SoSFDouble

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFDouble_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFDouble_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFDouble self) -> SoType"""
        return _coin.SoSFDouble_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFDouble self, SoField field)"""
        return _coin.SoSFDouble_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFDouble self, SoField field) -> SbBool"""
        return _coin.SoSFDouble_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFDouble self) -> double"""
        return _coin.SoSFDouble_getValue(self)

    def setValue(self, newvalue):
        r"""setValue(SoSFDouble self, double newvalue)"""
        return _coin.SoSFDouble_setValue(self, newvalue)

    def __eq__(self, field):
        r"""__eq__(SoSFDouble self, SoSFDouble field) -> int"""
        return _coin.SoSFDouble___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFDouble self, SoSFDouble field) -> int"""
        return _coin.SoSFDouble___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFDouble_initClass()

# Register SoSFDouble in _coin:
_coin.SoSFDouble_swigregister(SoSFDouble)
class SoSFEngine(SoSField):
    r"""Proxy of C++ SoSFEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFEngine self) -> SoSFEngine"""
        _coin.SoSFEngine_swiginit(self, _coin.new_SoSFEngine())
    __swig_destroy__ = _coin.delete_SoSFEngine

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFEngine_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFEngine_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFEngine self) -> SoType"""
        return _coin.SoSFEngine_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFEngine self, SoField field)"""
        return _coin.SoSFEngine_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFEngine self, SoField field) -> SbBool"""
        return _coin.SoSFEngine_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFEngine self) -> SoEngine"""
        return _coin.SoSFEngine_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFEngine self, SoSFEngine field) -> int"""
        return _coin.SoSFEngine___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFEngine self, SoSFEngine field) -> int"""
        return _coin.SoSFEngine___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFEngine_initClass()

    def fixCopy(self, copyconnections):
        r"""fixCopy(SoSFEngine self, SbBool copyconnections)"""
        return _coin.SoSFEngine_fixCopy(self, copyconnections)

    def referencesCopy(self):
        r"""referencesCopy(SoSFEngine self) -> SbBool"""
        return _coin.SoSFEngine_referencesCopy(self)

    def setValue(self, *args):
        r"""
        setValue(SoSFEngine self, SoEngine newvalue)
        setValue(SoSFEngine self, SoSFEngine other)
        """
        return _coin.SoSFEngine_setValue(self, *args)

# Register SoSFEngine in _coin:
_coin.SoSFEngine_swigregister(SoSFEngine)
class SoSFImage3(SoSField):
    r"""Proxy of C++ SoSFImage3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFImage3 self) -> SoSFImage3"""
        _coin.SoSFImage3_swiginit(self, _coin.new_SoSFImage3())
    __swig_destroy__ = _coin.delete_SoSFImage3

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFImage3_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFImage3_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFImage3 self) -> SoType"""
        return _coin.SoSFImage3_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFImage3 self, SoField field)"""
        return _coin.SoSFImage3_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFImage3 self, SoField field) -> SbBool"""
        return _coin.SoSFImage3_isSame(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFImage3_initClass()

    def getValue(self):
        r"""getValue(SoSFImage3 self) -> unsigned char const *"""
        return _coin.SoSFImage3_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFImage3 self, SoSFImage3 field) -> int"""
        return _coin.SoSFImage3___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFImage3 self, SoSFImage3 field) -> int"""
        return _coin.SoSFImage3___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoSFImage3 self) -> unsigned char *"""
        return _coin.SoSFImage3_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoSFImage3 self)"""
        return _coin.SoSFImage3_finishEditing(self)

    def setValue(self, *args):
        r"""
        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)

# Register SoSFImage3 in _coin:
_coin.SoSFImage3_swigregister(SoSFImage3)
class SoSFMatrix(SoSField):
    r"""Proxy of C++ SoSFMatrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFMatrix self) -> SoSFMatrix"""
        _coin.SoSFMatrix_swiginit(self, _coin.new_SoSFMatrix())
    __swig_destroy__ = _coin.delete_SoSFMatrix

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFMatrix_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFMatrix_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFMatrix self) -> SoType"""
        return _coin.SoSFMatrix_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFMatrix self, SoField field)"""
        return _coin.SoSFMatrix_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFMatrix self, SoField field) -> SbBool"""
        return _coin.SoSFMatrix_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFMatrix self) -> SbMatrix"""
        return _coin.SoSFMatrix_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFMatrix self, SoSFMatrix field) -> int"""
        return _coin.SoSFMatrix___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFMatrix self, SoSFMatrix field) -> int"""
        return _coin.SoSFMatrix___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFMatrix_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFMatrix in _coin:
_coin.SoSFMatrix_swigregister(SoSFMatrix)
class SoSFPlane(SoSField):
    r"""Proxy of C++ SoSFPlane class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFPlane self) -> SoSFPlane"""
        _coin.SoSFPlane_swiginit(self, _coin.new_SoSFPlane())
    __swig_destroy__ = _coin.delete_SoSFPlane

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFPlane_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFPlane_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFPlane self) -> SoType"""
        return _coin.SoSFPlane_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFPlane self, SoField field)"""
        return _coin.SoSFPlane_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFPlane self, SoField field) -> SbBool"""
        return _coin.SoSFPlane_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFPlane self) -> SbPlane"""
        return _coin.SoSFPlane_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFPlane self, SoSFPlane field) -> int"""
        return _coin.SoSFPlane___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFPlane self, SoSFPlane field) -> int"""
        return _coin.SoSFPlane___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFPlane_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFPlane self, SbPlane newvalue)
        setValue(SoSFPlane self, SoSFPlane other)
        """
        return _coin.SoSFPlane_setValue(self, *args)

# Register SoSFPlane in _coin:
_coin.SoSFPlane_swigregister(SoSFPlane)
class SoSFUInt32(SoSField):
    r"""Proxy of C++ SoSFUInt32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFUInt32 self) -> SoSFUInt32"""
        _coin.SoSFUInt32_swiginit(self, _coin.new_SoSFUInt32())
    __swig_destroy__ = _coin.delete_SoSFUInt32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFUInt32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFUInt32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFUInt32 self) -> SoType"""
        return _coin.SoSFUInt32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFUInt32 self, SoField field)"""
        return _coin.SoSFUInt32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFUInt32 self, SoField field) -> SbBool"""
        return _coin.SoSFUInt32_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFUInt32 self) -> uint32_t"""
        return _coin.SoSFUInt32_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFUInt32 self, SoSFUInt32 field) -> int"""
        return _coin.SoSFUInt32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFUInt32 self, SoSFUInt32 field) -> int"""
        return _coin.SoSFUInt32___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFUInt32_initClass()

    def setValue(self, *args):
        r"""
        setValue(SoSFUInt32 self, uint32_t newvalue)
        setValue(SoSFUInt32 self, SoSFUInt32 other)
        """
        return _coin.SoSFUInt32_setValue(self, *args)

# Register SoSFUInt32 in _coin:
_coin.SoSFUInt32_swigregister(SoSFUInt32)
class SbVec2b(object):
    r"""Proxy of C++ SbVec2b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec2b_swiginit(self, _coin.new_SbVec2b(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec2b self, SbVec2b v) -> int32_t"""
        return _coin.SbVec2b_dot(self, v)

    def negate(self):
        r"""negate(SbVec2b self)"""
        return _coin.SbVec2b_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec2b self, int d) -> SbVec2b
        __imul__(SbVec2b self, double d) -> SbVec2b
        """
        return _coin.SbVec2b___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec2b___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec2b self, SbVec2b v) -> SbVec2b"""
        return _coin.SbVec2b___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec2b self, SbVec2b v) -> SbVec2b"""
        return _coin.SbVec2b___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec2b self) -> SbVec2b"""
        return _coin.SbVec2b___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec2b

# Register SbVec2b in _coin:
_coin.SbVec2b_swigregister(SbVec2b)
class SoSFVec2b(SoSField):
    r"""Proxy of C++ SoSFVec2b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec2b self) -> SoSFVec2b"""
        _coin.SoSFVec2b_swiginit(self, _coin.new_SoSFVec2b())
    __swig_destroy__ = _coin.delete_SoSFVec2b

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2b_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2b_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec2b self) -> SoType"""
        return _coin.SoSFVec2b_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec2b self, SoField field)"""
        return _coin.SoSFVec2b_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec2b self, SoField field) -> SbBool"""
        return _coin.SoSFVec2b_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec2b self) -> SbVec2b"""
        return _coin.SoSFVec2b_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec2b self, SoSFVec2b field) -> int"""
        return _coin.SoSFVec2b___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec2b self, SoSFVec2b field) -> int"""
        return _coin.SoSFVec2b___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec2b_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec2b in _coin:
_coin.SoSFVec2b_swigregister(SoSFVec2b)
class SoSFVec2s(SoSField):
    r"""Proxy of C++ SoSFVec2s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec2s self) -> SoSFVec2s"""
        _coin.SoSFVec2s_swiginit(self, _coin.new_SoSFVec2s())
    __swig_destroy__ = _coin.delete_SoSFVec2s

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2s_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2s_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec2s self) -> SoType"""
        return _coin.SoSFVec2s_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec2s self, SoField field)"""
        return _coin.SoSFVec2s_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec2s self, SoField field) -> SbBool"""
        return _coin.SoSFVec2s_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec2s self) -> SbVec2s"""
        return _coin.SoSFVec2s_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec2s self, SoSFVec2s field) -> int"""
        return _coin.SoSFVec2s___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec2s self, SoSFVec2s field) -> int"""
        return _coin.SoSFVec2s___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec2s_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec2s in _coin:
_coin.SoSFVec2s_swigregister(SoSFVec2s)
class SoSFVec2i32(SoSField):
    r"""Proxy of C++ SoSFVec2i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec2i32 self) -> SoSFVec2i32"""
        _coin.SoSFVec2i32_swiginit(self, _coin.new_SoSFVec2i32())
    __swig_destroy__ = _coin.delete_SoSFVec2i32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2i32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2i32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec2i32 self) -> SoType"""
        return _coin.SoSFVec2i32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec2i32 self, SoField field)"""
        return _coin.SoSFVec2i32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec2i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec2i32_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec2i32 self) -> SbVec2i32"""
        return _coin.SoSFVec2i32_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec2i32 self, SoSFVec2i32 field) -> int"""
        return _coin.SoSFVec2i32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec2i32 self, SoSFVec2i32 field) -> int"""
        return _coin.SoSFVec2i32___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec2i32_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec2i32 in _coin:
_coin.SoSFVec2i32_swigregister(SoSFVec2i32)
class SoSFVec2d(SoSField):
    r"""Proxy of C++ SoSFVec2d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec2d self) -> SoSFVec2d"""
        _coin.SoSFVec2d_swiginit(self, _coin.new_SoSFVec2d())
    __swig_destroy__ = _coin.delete_SoSFVec2d

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec2d_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec2d_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec2d self) -> SoType"""
        return _coin.SoSFVec2d_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec2d self, SoField field)"""
        return _coin.SoSFVec2d_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec2d self, SoField field) -> SbBool"""
        return _coin.SoSFVec2d_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec2d self) -> SbVec2d"""
        return _coin.SoSFVec2d_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec2d self, SoSFVec2d field) -> int"""
        return _coin.SoSFVec2d___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec2d self, SoSFVec2d field) -> int"""
        return _coin.SoSFVec2d___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec2d_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec2d in _coin:
_coin.SoSFVec2d_swigregister(SoSFVec2d)
class SbVec3b(object):
    r"""Proxy of C++ SbVec3b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec3b_swiginit(self, _coin.new_SbVec3b(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec3b self, SbVec3b v) -> int32_t"""
        return _coin.SbVec3b_dot(self, v)

    def negate(self):
        r"""negate(SbVec3b self)"""
        return _coin.SbVec3b_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec3b self, int d) -> SbVec3b
        __imul__(SbVec3b self, double d) -> SbVec3b
        """
        return _coin.SbVec3b___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec3b___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec3b self, SbVec3b v) -> SbVec3b"""
        return _coin.SbVec3b___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec3b self, SbVec3b v) -> SbVec3b"""
        return _coin.SbVec3b___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec3b self) -> SbVec3b"""
        return _coin.SbVec3b___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec3b

# Register SbVec3b in _coin:
_coin.SbVec3b_swigregister(SbVec3b)
class SoSFVec3b(SoSField):
    r"""Proxy of C++ SoSFVec3b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec3b self) -> SoSFVec3b"""
        _coin.SoSFVec3b_swiginit(self, _coin.new_SoSFVec3b())
    __swig_destroy__ = _coin.delete_SoSFVec3b

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3b_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3b_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec3b self) -> SoType"""
        return _coin.SoSFVec3b_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec3b self, SoField field)"""
        return _coin.SoSFVec3b_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec3b self, SoField field) -> SbBool"""
        return _coin.SoSFVec3b_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec3b self) -> SbVec3b"""
        return _coin.SoSFVec3b_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec3b self, SoSFVec3b field) -> int"""
        return _coin.SoSFVec3b___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec3b self, SoSFVec3b field) -> int"""
        return _coin.SoSFVec3b___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec3b_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec3b in _coin:
_coin.SoSFVec3b_swigregister(SoSFVec3b)
class SoSFVec3s(SoSField):
    r"""Proxy of C++ SoSFVec3s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec3s self) -> SoSFVec3s"""
        _coin.SoSFVec3s_swiginit(self, _coin.new_SoSFVec3s())
    __swig_destroy__ = _coin.delete_SoSFVec3s

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3s_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3s_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec3s self) -> SoType"""
        return _coin.SoSFVec3s_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec3s self, SoField field)"""
        return _coin.SoSFVec3s_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec3s self, SoField field) -> SbBool"""
        return _coin.SoSFVec3s_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec3s self) -> SbVec3s"""
        return _coin.SoSFVec3s_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec3s self, SoSFVec3s field) -> int"""
        return _coin.SoSFVec3s___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec3s self, SoSFVec3s field) -> int"""
        return _coin.SoSFVec3s___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec3s_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec3s in _coin:
_coin.SoSFVec3s_swigregister(SoSFVec3s)
class SoSFVec3i32(SoSField):
    r"""Proxy of C++ SoSFVec3i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec3i32 self) -> SoSFVec3i32"""
        _coin.SoSFVec3i32_swiginit(self, _coin.new_SoSFVec3i32())
    __swig_destroy__ = _coin.delete_SoSFVec3i32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3i32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3i32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec3i32 self) -> SoType"""
        return _coin.SoSFVec3i32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec3i32 self, SoField field)"""
        return _coin.SoSFVec3i32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec3i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec3i32_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec3i32 self) -> SbVec3i32"""
        return _coin.SoSFVec3i32_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec3i32 self, SoSFVec3i32 field) -> int"""
        return _coin.SoSFVec3i32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec3i32 self, SoSFVec3i32 field) -> int"""
        return _coin.SoSFVec3i32___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec3i32_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec3i32 in _coin:
_coin.SoSFVec3i32_swigregister(SoSFVec3i32)
class SoSFVec3d(SoSField):
    r"""Proxy of C++ SoSFVec3d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec3d self) -> SoSFVec3d"""
        _coin.SoSFVec3d_swiginit(self, _coin.new_SoSFVec3d())
    __swig_destroy__ = _coin.delete_SoSFVec3d

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec3d_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec3d_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec3d self) -> SoType"""
        return _coin.SoSFVec3d_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec3d self, SoField field)"""
        return _coin.SoSFVec3d_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec3d self, SoField field) -> SbBool"""
        return _coin.SoSFVec3d_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec3d self) -> SbVec3d"""
        return _coin.SoSFVec3d_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec3d self, SoSFVec3d field) -> int"""
        return _coin.SoSFVec3d___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec3d self, SoSFVec3d field) -> int"""
        return _coin.SoSFVec3d___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec3d_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec3d in _coin:
_coin.SoSFVec3d_swigregister(SoSFVec3d)
class SbVec4b(object):
    r"""Proxy of C++ SbVec4b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec4b_swiginit(self, _coin.new_SbVec4b(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec4b self, SbVec4b v) -> int32_t"""
        return _coin.SbVec4b_dot(self, v)

    def negate(self):
        r"""negate(SbVec4b self)"""
        return _coin.SbVec4b_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec4b self, int d) -> SbVec4b
        __imul__(SbVec4b self, double d) -> SbVec4b
        """
        return _coin.SbVec4b___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4b___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec4b self, SbVec4b v) -> SbVec4b"""
        return _coin.SbVec4b___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec4b self, SbVec4b v) -> SbVec4b"""
        return _coin.SbVec4b___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec4b self) -> SbVec4b"""
        return _coin.SbVec4b___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4b

# Register SbVec4b in _coin:
_coin.SbVec4b_swigregister(SbVec4b)
class SoSFVec4b(SoSField):
    r"""Proxy of C++ SoSFVec4b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec4b self) -> SoSFVec4b"""
        _coin.SoSFVec4b_swiginit(self, _coin.new_SoSFVec4b())
    __swig_destroy__ = _coin.delete_SoSFVec4b

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4b_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4b_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec4b self) -> SoType"""
        return _coin.SoSFVec4b_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec4b self, SoField field)"""
        return _coin.SoSFVec4b_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec4b self, SoField field) -> SbBool"""
        return _coin.SoSFVec4b_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec4b self) -> SbVec4b"""
        return _coin.SoSFVec4b_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec4b self, SoSFVec4b field) -> int"""
        return _coin.SoSFVec4b___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec4b self, SoSFVec4b field) -> int"""
        return _coin.SoSFVec4b___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec4b_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec4b in _coin:
_coin.SoSFVec4b_swigregister(SoSFVec4b)
class SbVec4ub(object):
    r"""Proxy of C++ SbVec4ub class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec4ub_swiginit(self, _coin.new_SbVec4ub(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec4ub self, SbVec4ub v) -> int32_t"""
        return _coin.SbVec4ub_dot(self, v)

    def negate(self):
        r"""negate(SbVec4ub self)"""
        return _coin.SbVec4ub_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec4ub self, int d) -> SbVec4ub
        __imul__(SbVec4ub self, double d) -> SbVec4ub
        """
        return _coin.SbVec4ub___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4ub___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec4ub self, SbVec4ub v) -> SbVec4ub"""
        return _coin.SbVec4ub___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec4ub self, SbVec4ub v) -> SbVec4ub"""
        return _coin.SbVec4ub___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec4ub self) -> SbVec4ub"""
        return _coin.SbVec4ub___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4ub

# Register SbVec4ub in _coin:
_coin.SbVec4ub_swigregister(SbVec4ub)
class SoSFVec4ub(SoSField):
    r"""Proxy of C++ SoSFVec4ub class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec4ub self) -> SoSFVec4ub"""
        _coin.SoSFVec4ub_swiginit(self, _coin.new_SoSFVec4ub())
    __swig_destroy__ = _coin.delete_SoSFVec4ub

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4ub_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4ub_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec4ub self) -> SoType"""
        return _coin.SoSFVec4ub_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec4ub self, SoField field)"""
        return _coin.SoSFVec4ub_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec4ub self, SoField field) -> SbBool"""
        return _coin.SoSFVec4ub_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec4ub self) -> SbVec4ub"""
        return _coin.SoSFVec4ub_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec4ub self, SoSFVec4ub field) -> int"""
        return _coin.SoSFVec4ub___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec4ub self, SoSFVec4ub field) -> int"""
        return _coin.SoSFVec4ub___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec4ub_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec4ub in _coin:
_coin.SoSFVec4ub_swigregister(SoSFVec4ub)
class SbVec4s(object):
    r"""Proxy of C++ SbVec4s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec4s_swiginit(self, _coin.new_SbVec4s(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        getValue(SbVec4s self) -> short const
        getValue(SbVec4s self, short & w)
        """
        return _coin.SbVec4s_getValue(self, *args)

    def dot(self, v):
        r"""dot(SbVec4s self, SbVec4s v) -> int32_t"""
        return _coin.SbVec4s_dot(self, v)

    def negate(self):
        r"""negate(SbVec4s self)"""
        return _coin.SbVec4s_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec4s self, int d) -> SbVec4s
        __imul__(SbVec4s self, double d) -> SbVec4s
        """
        return _coin.SbVec4s___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4s___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec4s self, SbVec4s v) -> SbVec4s"""
        return _coin.SbVec4s___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec4s self, SbVec4s v) -> SbVec4s"""
        return _coin.SbVec4s___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec4s self) -> SbVec4s"""
        return _coin.SbVec4s___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4s

# Register SbVec4s in _coin:
_coin.SbVec4s_swigregister(SbVec4s)
class SoSFVec4s(SoSField):
    r"""Proxy of C++ SoSFVec4s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec4s self) -> SoSFVec4s"""
        _coin.SoSFVec4s_swiginit(self, _coin.new_SoSFVec4s())
    __swig_destroy__ = _coin.delete_SoSFVec4s

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4s_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4s_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec4s self) -> SoType"""
        return _coin.SoSFVec4s_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec4s self, SoField field)"""
        return _coin.SoSFVec4s_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec4s self, SoField field) -> SbBool"""
        return _coin.SoSFVec4s_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec4s self) -> SbVec4s"""
        return _coin.SoSFVec4s_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec4s self, SoSFVec4s field) -> int"""
        return _coin.SoSFVec4s___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec4s self, SoSFVec4s field) -> int"""
        return _coin.SoSFVec4s___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec4s_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec4s in _coin:
_coin.SoSFVec4s_swigregister(SoSFVec4s)
class SbVec4us(object):
    r"""Proxy of C++ SbVec4us class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec4us_swiginit(self, _coin.new_SbVec4us(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec4us self, SbVec4us v) -> int32_t"""
        return _coin.SbVec4us_dot(self, v)

    def negate(self):
        r"""negate(SbVec4us self)"""
        return _coin.SbVec4us_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec4us self, int d) -> SbVec4us
        __imul__(SbVec4us self, double d) -> SbVec4us
        """
        return _coin.SbVec4us___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4us___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec4us self, SbVec4us v) -> SbVec4us"""
        return _coin.SbVec4us___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec4us self, SbVec4us v) -> SbVec4us"""
        return _coin.SbVec4us___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec4us self) -> SbVec4us"""
        return _coin.SbVec4us___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4us

# Register SbVec4us in _coin:
_coin.SbVec4us_swigregister(SbVec4us)
class SoSFVec4us(SoSField):
    r"""Proxy of C++ SoSFVec4us class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec4us self) -> SoSFVec4us"""
        _coin.SoSFVec4us_swiginit(self, _coin.new_SoSFVec4us())
    __swig_destroy__ = _coin.delete_SoSFVec4us

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4us_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4us_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec4us self) -> SoType"""
        return _coin.SoSFVec4us_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec4us self, SoField field)"""
        return _coin.SoSFVec4us_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec4us self, SoField field) -> SbBool"""
        return _coin.SoSFVec4us_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec4us self) -> SbVec4us"""
        return _coin.SoSFVec4us_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec4us self, SoSFVec4us field) -> int"""
        return _coin.SoSFVec4us___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec4us self, SoSFVec4us field) -> int"""
        return _coin.SoSFVec4us___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec4us_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec4us in _coin:
_coin.SoSFVec4us_swigregister(SoSFVec4us)
class SbVec4i32(object):
    r"""Proxy of C++ SbVec4i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec4i32_swiginit(self, _coin.new_SbVec4i32(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec4i32 self, SbVec4i32 v) -> int32_t"""
        return _coin.SbVec4i32_dot(self, v)

    def negate(self):
        r"""negate(SbVec4i32 self)"""
        return _coin.SbVec4i32_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec4i32 self, int d) -> SbVec4i32
        __imul__(SbVec4i32 self, double d) -> SbVec4i32
        """
        return _coin.SbVec4i32___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4i32___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec4i32 self, SbVec4i32 v) -> SbVec4i32"""
        return _coin.SbVec4i32___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec4i32 self, SbVec4i32 v) -> SbVec4i32"""
        return _coin.SbVec4i32___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec4i32 self) -> SbVec4i32"""
        return _coin.SbVec4i32___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4i32

# Register SbVec4i32 in _coin:
_coin.SbVec4i32_swigregister(SbVec4i32)
class SoSFVec4i32(SoSField):
    r"""Proxy of C++ SoSFVec4i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec4i32 self) -> SoSFVec4i32"""
        _coin.SoSFVec4i32_swiginit(self, _coin.new_SoSFVec4i32())
    __swig_destroy__ = _coin.delete_SoSFVec4i32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4i32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4i32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec4i32 self) -> SoType"""
        return _coin.SoSFVec4i32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec4i32 self, SoField field)"""
        return _coin.SoSFVec4i32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec4i32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec4i32_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec4i32 self) -> SbVec4i32"""
        return _coin.SoSFVec4i32_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec4i32 self, SoSFVec4i32 field) -> int"""
        return _coin.SoSFVec4i32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec4i32 self, SoSFVec4i32 field) -> int"""
        return _coin.SoSFVec4i32___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec4i32_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec4i32 in _coin:
_coin.SoSFVec4i32_swigregister(SoSFVec4i32)
class SbVec4ui32(object):
    r"""Proxy of C++ SbVec4ui32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec4ui32_swiginit(self, _coin.new_SbVec4ui32(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""dot(SbVec4ui32 self, SbVec4ui32 v) -> int32_t"""
        return _coin.SbVec4ui32_dot(self, v)

    def negate(self):
        r"""negate(SbVec4ui32 self)"""
        return _coin.SbVec4ui32_negate(self)

    def __imul__(self, *args):
        r"""
        __imul__(SbVec4ui32 self, int d) -> SbVec4ui32
        __imul__(SbVec4ui32 self, double d) -> SbVec4ui32
        """
        return _coin.SbVec4ui32___imul__(self, *args)

    def __itruediv__(self, *args):
        return _coin.SbVec4ui32___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec4ui32 self, SbVec4ui32 v) -> SbVec4ui32"""
        return _coin.SbVec4ui32___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec4ui32 self, SbVec4ui32 v) -> SbVec4ui32"""
        return _coin.SbVec4ui32___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec4ui32 self) -> SbVec4ui32"""
        return _coin.SbVec4ui32___neg__(self)
    __swig_destroy__ = _coin.delete_SbVec4ui32

# Register SbVec4ui32 in _coin:
_coin.SbVec4ui32_swigregister(SbVec4ui32)
class SoSFVec4ui32(SoSField):
    r"""Proxy of C++ SoSFVec4ui32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec4ui32 self) -> SoSFVec4ui32"""
        _coin.SoSFVec4ui32_swiginit(self, _coin.new_SoSFVec4ui32())
    __swig_destroy__ = _coin.delete_SoSFVec4ui32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4ui32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4ui32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec4ui32 self) -> SoType"""
        return _coin.SoSFVec4ui32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec4ui32 self, SoField field)"""
        return _coin.SoSFVec4ui32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec4ui32 self, SoField field) -> SbBool"""
        return _coin.SoSFVec4ui32_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec4ui32 self) -> SbVec4ui32"""
        return _coin.SoSFVec4ui32_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec4ui32 self, SoSFVec4ui32 field) -> int"""
        return _coin.SoSFVec4ui32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec4ui32 self, SoSFVec4ui32 field) -> int"""
        return _coin.SoSFVec4ui32___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec4ui32_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec4ui32 in _coin:
_coin.SoSFVec4ui32_swigregister(SoSFVec4ui32)
class SoSFVec4f(SoSField):
    r"""Proxy of C++ SoSFVec4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec4f self) -> SoSFVec4f"""
        _coin.SoSFVec4f_swiginit(self, _coin.new_SoSFVec4f())
    __swig_destroy__ = _coin.delete_SoSFVec4f

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4f_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec4f self) -> SoType"""
        return _coin.SoSFVec4f_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec4f self, SoField field)"""
        return _coin.SoSFVec4f_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec4f self, SoField field) -> SbBool"""
        return _coin.SoSFVec4f_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec4f self) -> SbVec4f"""
        return _coin.SoSFVec4f_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec4f self, SoSFVec4f field) -> int"""
        return _coin.SoSFVec4f___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec4f self, SoSFVec4f field) -> int"""
        return _coin.SoSFVec4f___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec4f_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec4f in _coin:
_coin.SoSFVec4f_swigregister(SoSFVec4f)
class SbVec4d(object):
    r"""Proxy of C++ SbVec4d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbVec4d_swiginit(self, _coin.new_SbVec4d(*args))

    def setValue(self, *args):
        r"""
        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):
        r"""getValue(SbVec4d self) -> double const *"""
        return _coin.SbVec4d_getValue(self)

    def dot(self, v):
        r"""dot(SbVec4d self, SbVec4d v) -> double"""
        return _coin.SbVec4d_dot(self, v)

    def equals(self, v, tolerance):
        r"""equals(SbVec4d self, SbVec4d v, double tolerance) -> SbBool"""
        return _coin.SbVec4d_equals(self, v, tolerance)

    def getReal(self, v):
        r"""getReal(SbVec4d self, SbVec3d v)"""
        return _coin.SbVec4d_getReal(self, v)

    def length(self):
        r"""length(SbVec4d self) -> double"""
        return _coin.SbVec4d_length(self)

    def sqrLength(self):
        r"""sqrLength(SbVec4d self) -> double"""
        return _coin.SbVec4d_sqrLength(self)

    def negate(self):
        r"""negate(SbVec4d self)"""
        return _coin.SbVec4d_negate(self)

    def normalize(self):
        r"""normalize(SbVec4d self) -> double"""
        return _coin.SbVec4d_normalize(self)

    def __imul__(self, d):
        r"""__imul__(SbVec4d self, double d) -> SbVec4d"""
        return _coin.SbVec4d___imul__(self, d)

    def __itruediv__(self, *args):
        return _coin.SbVec4d___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        r"""__iadd__(SbVec4d self, SbVec4d v) -> SbVec4d"""
        return _coin.SbVec4d___iadd__(self, v)

    def __isub__(self, v):
        r"""__isub__(SbVec4d self, SbVec4d v) -> SbVec4d"""
        return _coin.SbVec4d___isub__(self, v)

    def __neg__(self):
        r"""__neg__(SbVec4d self) -> SbVec4d"""
        return _coin.SbVec4d___neg__(self)

    def output(self, fp):
        r"""output(SbVec4d self, FILE * fp)"""
        return _coin.SbVec4d_output(self, fp)

    def __add__(self, u):
        r"""__add__(SbVec4d self, SbVec4d u) -> SbVec4d"""
        return _coin.SbVec4d___add__(self, u)

    def __sub__(self, u):
        r"""__sub__(SbVec4d self, SbVec4d u) -> SbVec4d"""
        return _coin.SbVec4d___sub__(self, u)

    def __mul__(self, *args):
        r"""
        __mul__(SbVec4d self, double const d) -> SbVec4d
        __mul__(SbVec4d self, SbDPMatrix m) -> SbVec4d
        """
        return _coin.SbVec4d___mul__(self, *args)

    def __rmul__(self, d):
        r"""__rmul__(SbVec4d self, double const d) -> SbVec4d"""
        return _coin.SbVec4d___rmul__(self, d)

    def __div__(self, d):
        r"""__div__(SbVec4d self, double const d) -> SbVec4d"""
        return _coin.SbVec4d___div__(self, d)

    def __truediv__(self, d):
        r"""__truediv__(SbVec4d self, double const d) -> SbVec4d"""
        return _coin.SbVec4d___truediv__(self, d)

    def __eq__(self, u):
        r"""__eq__(SbVec4d self, SbVec4d u) -> int"""
        return _coin.SbVec4d___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbVec4d self, SbVec4d u) -> int"""
        return _coin.SbVec4d___nq__(self, u)

    def __getitem__(self, i):
        r"""__getitem__(SbVec4d self, int i) -> double"""
        return _coin.SbVec4d___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__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

# Register SbVec4d in _coin:
_coin.SbVec4d_swigregister(SbVec4d)
class SoSFVec4d(SoSField):
    r"""Proxy of C++ SoSFVec4d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSFVec4d self) -> SoSFVec4d"""
        _coin.SoSFVec4d_swiginit(self, _coin.new_SoSFVec4d())
    __swig_destroy__ = _coin.delete_SoSFVec4d

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoSFVec4d_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSFVec4d_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSFVec4d self) -> SoType"""
        return _coin.SoSFVec4d_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoSFVec4d self, SoField field)"""
        return _coin.SoSFVec4d_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoSFVec4d self, SoField field) -> SbBool"""
        return _coin.SoSFVec4d_isSame(self, field)

    def getValue(self):
        r"""getValue(SoSFVec4d self) -> SbVec4d"""
        return _coin.SoSFVec4d_getValue(self)

    def __eq__(self, field):
        r"""__eq__(SoSFVec4d self, SoSFVec4d field) -> int"""
        return _coin.SoSFVec4d___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoSFVec4d self, SoSFVec4d field) -> int"""
        return _coin.SoSFVec4d___ne__(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSFVec4d_initClass()

    def setValue(self, *args):
        r"""
        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)

# Register SoSFVec4d in _coin:
_coin.SoSFVec4d_swigregister(SoSFVec4d)
class SoMFColor(SoMField):
    r"""Proxy of C++ SoMFColor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFColor self) -> SoMFColor"""
        _coin.SoMFColor_swiginit(self, _coin.new_SoMFColor())
    __swig_destroy__ = _coin.delete_SoMFColor

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFColor_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFColor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFColor self) -> SoType"""
        return _coin.SoMFColor_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFColor self, SoField field)"""
        return _coin.SoMFColor_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFColor self, SoField field) -> SbBool"""
        return _coin.SoMFColor_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFColor self, SbColor value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFColor_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFColor self, SoMFColor field) -> SbBool"""
        return _coin.SoMFColor___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFColor self, SoMFColor field) -> SbBool"""
        return _coin.SoMFColor___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFColor self) -> SbColor"""
        return _coin.SoMFColor_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFColor self)"""
        return _coin.SoMFColor_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFColor_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 _coin.SoMFColor_setValues(*args)



    def setHSVValues(self, start, num, hsv):
        r"""setHSVValues(SoMFColor self, int start, int num, float const [][3] hsv)"""
        return _coin.SoMFColor_setHSVValues(self, start, num, hsv)

    def setHSVValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""__getitem__(SoMFColor self, int i) -> SbColor"""
        return _coin.SoMFColor___getitem__(self, i)

    def __setitem__(self, *args):
        r"""
        __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):
        r"""
        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):
        r"""getValues(SoMFColor self, int i=0) -> SbColor"""
        return _coin.SoMFColor_getValues(self, i)

# Register SoMFColor in _coin:
_coin.SoMFColor_swigregister(SoMFColor)
class SoMFColorRGBA(SoMField):
    r"""Proxy of C++ SoMFColorRGBA class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFColorRGBA self) -> SoMFColorRGBA"""
        _coin.SoMFColorRGBA_swiginit(self, _coin.new_SoMFColorRGBA())
    __swig_destroy__ = _coin.delete_SoMFColorRGBA

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFColorRGBA_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFColorRGBA_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFColorRGBA self) -> SoType"""
        return _coin.SoMFColorRGBA_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFColorRGBA self, SoField field)"""
        return _coin.SoMFColorRGBA_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFColorRGBA self, SoField field) -> SbBool"""
        return _coin.SoMFColorRGBA_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFColorRGBA self, int const start) -> SbColor4f"""
        return _coin.SoMFColorRGBA_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFColorRGBA self, SbColor4f value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFColorRGBA_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFColorRGBA self, SoMFColorRGBA field) -> SbBool"""
        return _coin.SoMFColorRGBA___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFColorRGBA self, SoMFColorRGBA field) -> SbBool"""
        return _coin.SoMFColorRGBA___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFColorRGBA self) -> SbColor4f"""
        return _coin.SoMFColorRGBA_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFColorRGBA self)"""
        return _coin.SoMFColorRGBA_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFColorRGBA_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""setHSVValues(SoMFColorRGBA self, int start, int num, float const [][4] hsv)"""
        return _coin.SoMFColorRGBA_setHSVValues(self, start, num, hsv)

    def setValue(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFColorRGBA in _coin:
_coin.SoMFColorRGBA_swigregister(SoMFColorRGBA)
class SoMFDouble(SoMField):
    r"""Proxy of C++ SoMFDouble class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFDouble self) -> SoMFDouble"""
        _coin.SoMFDouble_swiginit(self, _coin.new_SoMFDouble())
    __swig_destroy__ = _coin.delete_SoMFDouble

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFDouble_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFDouble_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFDouble self) -> SoType"""
        return _coin.SoMFDouble_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFDouble self, SoField field)"""
        return _coin.SoMFDouble_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFDouble self, SoField field) -> SbBool"""
        return _coin.SoMFDouble_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFDouble self, int const start) -> double const *"""
        return _coin.SoMFDouble_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFDouble self, double value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFDouble_find(self, value, addifnotfound)

    def setValues(self, start, num, newvals):
        r"""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):
        r"""set1Value(SoMFDouble self, int const idx, double value)"""
        return _coin.SoMFDouble_set1Value(self, idx, value)

    def setValue(self, value):
        r"""setValue(SoMFDouble self, double value)"""
        return _coin.SoMFDouble_setValue(self, value)

    def __eq__(self, field):
        r"""__eq__(SoMFDouble self, SoMFDouble field) -> SbBool"""
        return _coin.SoMFDouble___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFDouble self, SoMFDouble field) -> SbBool"""
        return _coin.SoMFDouble___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFDouble self) -> double *"""
        return _coin.SoMFDouble_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFDouble self)"""
        return _coin.SoMFDouble_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        setValuesPointer(SoMFDouble self, int const num, double const * userdata)
        setValuesPointer(SoMFDouble self, int const num, double * userdata)
        """
        return _coin.SoMFDouble_setValuesPointer(self, *args)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFDouble_initClass()

# Register SoMFDouble in _coin:
_coin.SoMFDouble_swigregister(SoMFDouble)
class SoMFEngine(SoMField):
    r"""Proxy of C++ SoMFEngine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFEngine self) -> SoMFEngine"""
        _coin.SoMFEngine_swiginit(self, _coin.new_SoMFEngine())
    __swig_destroy__ = _coin.delete_SoMFEngine

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFEngine_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFEngine_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFEngine self) -> SoType"""
        return _coin.SoMFEngine_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFEngine self, SoField field)"""
        return _coin.SoMFEngine_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFEngine self, SoField field) -> SbBool"""
        return _coin.SoMFEngine_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFEngine self, SoEngine value, SbBool addifnotfound=0) -> 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 _coin.SoMFEngine_setValues(*args)



    def set1Value(self, idx, value):
        r"""set1Value(SoMFEngine self, int const idx, SoEngine value)"""
        return _coin.SoMFEngine_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFEngine self, SoMFEngine field) -> SbBool"""
        return _coin.SoMFEngine___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFEngine self, SoMFEngine field) -> SbBool"""
        return _coin.SoMFEngine___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFEngine self) -> SoEngine **"""
        return _coin.SoMFEngine_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFEngine self)"""
        return _coin.SoMFEngine_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFEngine_initClass()

    def fixCopy(self, copyconnections):
        r"""fixCopy(SoMFEngine self, SbBool copyconnections)"""
        return _coin.SoMFEngine_fixCopy(self, copyconnections)

    def referencesCopy(self):
        r"""referencesCopy(SoMFEngine self) -> SbBool"""
        return _coin.SoMFEngine_referencesCopy(self)

    def deleteValues(self, start, num=-1):
        r"""deleteValues(SoMFEngine self, int start, int num=-1)"""
        return _coin.SoMFEngine_deleteValues(self, start, num)

    def insertSpace(self, start, num):
        r"""insertSpace(SoMFEngine self, int start, int num)"""
        return _coin.SoMFEngine_insertSpace(self, start, num)

    def __getitem__(self, i):
        r"""__getitem__(SoMFEngine self, int i) -> SoEngine"""
        return _coin.SoMFEngine___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFEngine self, int i, SoEngine value)"""
        return _coin.SoMFEngine___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        setValue(SoMFEngine self, SoEngine value)
        setValue(SoMFEngine self, SoMFEngine other)
        """
        return _coin.SoMFEngine_setValue(self, *args)

    def getValues(self, i=0):
        r"""getValues(SoMFEngine self, int i=0) -> SoEngine"""
        return _coin.SoMFEngine_getValues(self, i)

# Register SoMFEngine in _coin:
_coin.SoMFEngine_swigregister(SoMFEngine)
class SoMFBitMask(SoMFEnum):
    r"""Proxy of C++ SoMFBitMask class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFBitMask self) -> SoMFBitMask"""
        _coin.SoMFBitMask_swiginit(self, _coin.new_SoMFBitMask())
    __swig_destroy__ = _coin.delete_SoMFBitMask

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFBitMask_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFBitMask_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFBitMask self) -> SoType"""
        return _coin.SoMFBitMask_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFBitMask self, SoField field)"""
        return _coin.SoMFBitMask_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFBitMask self, SoField field) -> SbBool"""
        return _coin.SoMFBitMask_isSame(self, field)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFBitMask_initClass()

# Register SoMFBitMask in _coin:
_coin.SoMFBitMask_swigregister(SoMFBitMask)
class SoMFInt32(SoMField):
    r"""Proxy of C++ SoMFInt32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFInt32 self) -> SoMFInt32"""
        _coin.SoMFInt32_swiginit(self, _coin.new_SoMFInt32())
    __swig_destroy__ = _coin.delete_SoMFInt32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFInt32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFInt32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFInt32 self) -> SoType"""
        return _coin.SoMFInt32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFInt32 self, SoField field)"""
        return _coin.SoMFInt32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFInt32 self, SoField field) -> SbBool"""
        return _coin.SoMFInt32_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFInt32 self, int32_t value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFInt32 self, int const idx, int32_t value)"""
        return _coin.SoMFInt32_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFInt32 self, SoMFInt32 field) -> SbBool"""
        return _coin.SoMFInt32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFInt32 self, SoMFInt32 field) -> SbBool"""
        return _coin.SoMFInt32___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFInt32 self) -> int32_t *"""
        return _coin.SoMFInt32_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFInt32 self)"""
        return _coin.SoMFInt32_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFInt32_initClass()

    def __getitem__(self, i):
        r"""__getitem__(SoMFInt32 self, int i) -> int32_t const"""
        return _coin.SoMFInt32___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFInt32 self, int i, int32_t value)"""
        return _coin.SoMFInt32___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        setValue(SoMFInt32 self, int32_t value)
        setValue(SoMFInt32 self, SoMFInt32 other)
        """
        return _coin.SoMFInt32_setValue(self, *args)

    def getValues(self, i=0):
        r"""getValues(SoMFInt32 self, int32_t i=0) -> int32_t const"""
        return _coin.SoMFInt32_getValues(self, i)

# Register SoMFInt32 in _coin:
_coin.SoMFInt32_swigregister(SoMFInt32)
class SoMFNode(SoMField):
    r"""Proxy of C++ SoMFNode class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFNode self) -> SoMFNode"""
        _coin.SoMFNode_swiginit(self, _coin.new_SoMFNode())
    __swig_destroy__ = _coin.delete_SoMFNode

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFNode_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFNode_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFNode self) -> SoType"""
        return _coin.SoMFNode_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFNode self, SoField field)"""
        return _coin.SoMFNode_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFNode self, SoField field) -> SbBool"""
        return _coin.SoMFNode_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFNode self, SoNode value, SbBool addifnotfound=0) -> 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 _coin.SoMFNode_setValues(*args)



    def set1Value(self, idx, value):
        r"""set1Value(SoMFNode self, int const idx, SoNode value)"""
        return _coin.SoMFNode_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFNode self, SoMFNode field) -> SbBool"""
        return _coin.SoMFNode___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFNode self, SoMFNode field) -> SbBool"""
        return _coin.SoMFNode___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFNode self) -> SoNode **"""
        return _coin.SoMFNode_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFNode self)"""
        return _coin.SoMFNode_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFNode_initClass()

    def fixCopy(self, copyconnections):
        r"""fixCopy(SoMFNode self, SbBool copyconnections)"""
        return _coin.SoMFNode_fixCopy(self, copyconnections)

    def referencesCopy(self):
        r"""referencesCopy(SoMFNode self) -> SbBool"""
        return _coin.SoMFNode_referencesCopy(self)

    def addNode(self, node):
        r"""addNode(SoMFNode self, SoNode node)"""
        return _coin.SoMFNode_addNode(self, node)

    def insertNode(self, node, idx):
        r"""insertNode(SoMFNode self, SoNode node, int idx)"""
        return _coin.SoMFNode_insertNode(self, node, idx)

    def getNode(self, idx):
        r"""getNode(SoMFNode self, int idx) -> SoNode"""
        return _coin.SoMFNode_getNode(self, idx)

    def findNode(self, node):
        r"""findNode(SoMFNode self, SoNode node) -> int"""
        return _coin.SoMFNode_findNode(self, node)

    def getNumNodes(self):
        r"""getNumNodes(SoMFNode self) -> int"""
        return _coin.SoMFNode_getNumNodes(self)

    def removeNode(self, *args):
        r"""
        removeNode(SoMFNode self, int index)
        removeNode(SoMFNode self, SoNode node)
        """
        return _coin.SoMFNode_removeNode(self, *args)

    def removeAllNodes(self):
        r"""removeAllNodes(SoMFNode self)"""
        return _coin.SoMFNode_removeAllNodes(self)

    def replaceNode(self, *args):
        r"""
        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):
        r"""deleteValues(SoMFNode self, int start, int num=-1)"""
        return _coin.SoMFNode_deleteValues(self, start, num)

    def insertSpace(self, start, num):
        r"""insertSpace(SoMFNode self, int start, int num)"""
        return _coin.SoMFNode_insertSpace(self, start, num)

    def __getitem__(self, i):
        r"""__getitem__(SoMFNode self, int i) -> SoNode"""
        return _coin.SoMFNode___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFNode self, int i, SoNode value)"""
        return _coin.SoMFNode___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        setValue(SoMFNode self, SoNode value)
        setValue(SoMFNode self, SoMFNode other)
        """
        return _coin.SoMFNode_setValue(self, *args)

    def getValues(self, i=0):
        r"""getValues(SoMFNode self, int i=0) -> SoNode"""
        return _coin.SoMFNode_getValues(self, i)

# Register SoMFNode in _coin:
_coin.SoMFNode_swigregister(SoMFNode)
class SoMFPath(SoMField):
    r"""Proxy of C++ SoMFPath class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFPath self) -> SoMFPath"""
        _coin.SoMFPath_swiginit(self, _coin.new_SoMFPath())
    __swig_destroy__ = _coin.delete_SoMFPath

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFPath_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFPath_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFPath self) -> SoType"""
        return _coin.SoMFPath_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFPath self, SoField field)"""
        return _coin.SoMFPath_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFPath self, SoField field) -> SbBool"""
        return _coin.SoMFPath_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFPath self, SoPath value, SbBool addifnotfound=0) -> 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 _coin.SoMFPath_setValues(*args)



    def set1Value(self, idx, value):
        r"""set1Value(SoMFPath self, int const idx, SoPath value)"""
        return _coin.SoMFPath_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFPath self, SoMFPath field) -> SbBool"""
        return _coin.SoMFPath___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFPath self, SoMFPath field) -> SbBool"""
        return _coin.SoMFPath___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFPath self) -> SoPath **"""
        return _coin.SoMFPath_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFPath self)"""
        return _coin.SoMFPath_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFPath_initClass()

    def notify(self, l):
        r"""notify(SoMFPath self, SoNotList l)"""
        return _coin.SoMFPath_notify(self, l)

    def fixCopy(self, copyconnections):
        r"""fixCopy(SoMFPath self, SbBool copyconnections)"""
        return _coin.SoMFPath_fixCopy(self, copyconnections)

    def referencesCopy(self):
        r"""referencesCopy(SoMFPath self) -> SbBool"""
        return _coin.SoMFPath_referencesCopy(self)

    def deleteValues(self, start, num=-1):
        r"""deleteValues(SoMFPath self, int start, int num=-1)"""
        return _coin.SoMFPath_deleteValues(self, start, num)

    def insertSpace(self, start, num):
        r"""insertSpace(SoMFPath self, int start, int num)"""
        return _coin.SoMFPath_insertSpace(self, start, num)

    def __getitem__(self, i):
        r"""__getitem__(SoMFPath self, int i) -> SoPath"""
        return _coin.SoMFPath___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFPath self, int i, SoPath value)"""
        return _coin.SoMFPath___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        setValue(SoMFPath self, SoPath value)
        setValue(SoMFPath self, SoMFPath other)
        """
        return _coin.SoMFPath_setValue(self, *args)

    def getValues(self, i=0):
        r"""getValues(SoMFPath self, int i=0) -> SoPath"""
        return _coin.SoMFPath_getValues(self, i)

# Register SoMFPath in _coin:
_coin.SoMFPath_swigregister(SoMFPath)
class SoMFPlane(SoMField):
    r"""Proxy of C++ SoMFPlane class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFPlane self) -> SoMFPlane"""
        _coin.SoMFPlane_swiginit(self, _coin.new_SoMFPlane())
    __swig_destroy__ = _coin.delete_SoMFPlane

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFPlane_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFPlane_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFPlane self) -> SoType"""
        return _coin.SoMFPlane_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFPlane self, SoField field)"""
        return _coin.SoMFPlane_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFPlane self, SoField field) -> SbBool"""
        return _coin.SoMFPlane_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFPlane self, SbPlane value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFPlane self, int const idx, SbPlane value)"""
        return _coin.SoMFPlane_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFPlane self, SoMFPlane field) -> SbBool"""
        return _coin.SoMFPlane___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFPlane self, SoMFPlane field) -> SbBool"""
        return _coin.SoMFPlane___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFPlane self) -> SbPlane"""
        return _coin.SoMFPlane_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFPlane self)"""
        return _coin.SoMFPlane_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFPlane_initClass()

    def __getitem__(self, i):
        r"""__getitem__(SoMFPlane self, int i) -> SbPlane"""
        return _coin.SoMFPlane___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFPlane self, int i, SbPlane value)"""
        return _coin.SoMFPlane___setitem__(self, i, value)

    def getValues(self, i=0):
        r"""getValues(SoMFPlane self, int i=0) -> SbPlane"""
        return _coin.SoMFPlane_getValues(self, i)

    def setValue(self, *args):
        r"""
        setValue(SoMFPlane self, SbPlane value)
        setValue(SoMFPlane self, SoMFPlane other)
        """
        return _coin.SoMFPlane_setValue(self, *args)

# Register SoMFPlane in _coin:
_coin.SoMFPlane_swigregister(SoMFPlane)
class SoMFShort(SoMField):
    r"""Proxy of C++ SoMFShort class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFShort self) -> SoMFShort"""
        _coin.SoMFShort_swiginit(self, _coin.new_SoMFShort())
    __swig_destroy__ = _coin.delete_SoMFShort

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFShort_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFShort_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFShort self) -> SoType"""
        return _coin.SoMFShort_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFShort self, SoField field)"""
        return _coin.SoMFShort_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFShort self, SoField field) -> SbBool"""
        return _coin.SoMFShort_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFShort self, short value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFShort self, int const idx, short value)"""
        return _coin.SoMFShort_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFShort self, SoMFShort field) -> SbBool"""
        return _coin.SoMFShort___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFShort self, SoMFShort field) -> SbBool"""
        return _coin.SoMFShort___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFShort self) -> short *"""
        return _coin.SoMFShort_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFShort self)"""
        return _coin.SoMFShort_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        setValuesPointer(SoMFShort self, int const num, short const * userdata)
        setValuesPointer(SoMFShort self, int const num, short * userdata)
        """
        return _coin.SoMFShort_setValuesPointer(self, *args)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFShort_initClass()

    def __getitem__(self, i):
        r"""__getitem__(SoMFShort self, int i) -> short const"""
        return _coin.SoMFShort___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFShort self, int i, short value)"""
        return _coin.SoMFShort___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        setValue(SoMFShort self, short value)
        setValue(SoMFShort self, SoMFShort other)
        """
        return _coin.SoMFShort_setValue(self, *args)

    def getValues(self, i=0):
        r"""getValues(SoMFShort self, int i=0) -> short const"""
        return _coin.SoMFShort_getValues(self, i)

# Register SoMFShort in _coin:
_coin.SoMFShort_swigregister(SoMFShort)
class SoMFTime(SoMField):
    r"""Proxy of C++ SoMFTime class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFTime self) -> SoMFTime"""
        _coin.SoMFTime_swiginit(self, _coin.new_SoMFTime())
    __swig_destroy__ = _coin.delete_SoMFTime

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFTime_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFTime_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFTime self) -> SoType"""
        return _coin.SoMFTime_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFTime self, SoField field)"""
        return _coin.SoMFTime_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFTime self, SoField field) -> SbBool"""
        return _coin.SoMFTime_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFTime self, SbTime value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFTime self, int const idx, SbTime value)"""
        return _coin.SoMFTime_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFTime self, SoMFTime field) -> SbBool"""
        return _coin.SoMFTime___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFTime self, SoMFTime field) -> SbBool"""
        return _coin.SoMFTime___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFTime self) -> SbTime"""
        return _coin.SoMFTime_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFTime self)"""
        return _coin.SoMFTime_finishEditing(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFTime_initClass()

    def __getitem__(self, i):
        r"""__getitem__(SoMFTime self, int i) -> SbTime"""
        return _coin.SoMFTime___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFTime self, int i, SbTime value)"""
        return _coin.SoMFTime___setitem__(self, i, value)

    def getValues(self, i=0):
        r"""getValues(SoMFTime self, int i=0) -> SbTime"""
        return _coin.SoMFTime_getValues(self, i)

    def setValue(self, *args):
        r"""
        setValue(SoMFTime self, SbTime value)
        setValue(SoMFTime self, SoMFTime other)
        """
        return _coin.SoMFTime_setValue(self, *args)

# Register SoMFTime in _coin:
_coin.SoMFTime_swigregister(SoMFTime)
class SoMFUInt32(SoMField):
    r"""Proxy of C++ SoMFUInt32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFUInt32 self) -> SoMFUInt32"""
        _coin.SoMFUInt32_swiginit(self, _coin.new_SoMFUInt32())
    __swig_destroy__ = _coin.delete_SoMFUInt32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFUInt32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFUInt32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFUInt32 self) -> SoType"""
        return _coin.SoMFUInt32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFUInt32 self, SoField field)"""
        return _coin.SoMFUInt32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFUInt32 self, SoField field) -> SbBool"""
        return _coin.SoMFUInt32_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFUInt32 self, uint32_t value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFUInt32 self, int const idx, uint32_t value)"""
        return _coin.SoMFUInt32_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFUInt32 self, SoMFUInt32 field) -> SbBool"""
        return _coin.SoMFUInt32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFUInt32 self, SoMFUInt32 field) -> SbBool"""
        return _coin.SoMFUInt32___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFUInt32 self) -> uint32_t *"""
        return _coin.SoMFUInt32_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFUInt32 self)"""
        return _coin.SoMFUInt32_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFUInt32_initClass()

    def __getitem__(self, i):
        r"""__getitem__(SoMFUInt32 self, int i) -> uint32_t const"""
        return _coin.SoMFUInt32___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFUInt32 self, int i, uint32_t value)"""
        return _coin.SoMFUInt32___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        setValue(SoMFUInt32 self, uint32_t value)
        setValue(SoMFUInt32 self, SoMFUInt32 other)
        """
        return _coin.SoMFUInt32_setValue(self, *args)

    def getValues(self, i=0):
        r"""getValues(SoMFUInt32 self, int i=0) -> uint32_t const"""
        return _coin.SoMFUInt32_getValues(self, i)

# Register SoMFUInt32 in _coin:
_coin.SoMFUInt32_swigregister(SoMFUInt32)
class SoMFUShort(SoMField):
    r"""Proxy of C++ SoMFUShort class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFUShort self) -> SoMFUShort"""
        _coin.SoMFUShort_swiginit(self, _coin.new_SoMFUShort())
    __swig_destroy__ = _coin.delete_SoMFUShort

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFUShort_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFUShort_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFUShort self) -> SoType"""
        return _coin.SoMFUShort_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFUShort self, SoField field)"""
        return _coin.SoMFUShort_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFUShort self, SoField field) -> SbBool"""
        return _coin.SoMFUShort_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFUShort self, unsigned short value, SbBool addifnotfound=0) -> 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):
        r"""set1Value(SoMFUShort self, int const idx, unsigned short value)"""
        return _coin.SoMFUShort_set1Value(self, idx, value)

    def __eq__(self, field):
        r"""__eq__(SoMFUShort self, SoMFUShort field) -> SbBool"""
        return _coin.SoMFUShort___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFUShort self, SoMFUShort field) -> SbBool"""
        return _coin.SoMFUShort___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFUShort self) -> unsigned short *"""
        return _coin.SoMFUShort_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFUShort self)"""
        return _coin.SoMFUShort_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFUShort_initClass()

    def __getitem__(self, i):
        r"""__getitem__(SoMFUShort self, int i) -> short const"""
        return _coin.SoMFUShort___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFUShort self, int i, short value)"""
        return _coin.SoMFUShort___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        setValue(SoMFUShort self, unsigned short value)
        setValue(SoMFUShort self, SoMFUShort other)
        """
        return _coin.SoMFUShort_setValue(self, *args)

    def getValues(self, i=0):
        r"""getValues(SoMFUShort self, int i=0) -> unsigned short const"""
        return _coin.SoMFUShort_getValues(self, i)

# Register SoMFUShort in _coin:
_coin.SoMFUShort_swigregister(SoMFUShort)
class SoMFVec2b(SoMField):
    r"""Proxy of C++ SoMFVec2b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec2b self) -> SoMFVec2b"""
        _coin.SoMFVec2b_swiginit(self, _coin.new_SoMFVec2b())
    __swig_destroy__ = _coin.delete_SoMFVec2b

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2b_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2b_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec2b self) -> SoType"""
        return _coin.SoMFVec2b_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec2b self, SoField field)"""
        return _coin.SoMFVec2b_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec2b self, SoField field) -> SbBool"""
        return _coin.SoMFVec2b_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec2b self, int const start) -> SbVec2b"""
        return _coin.SoMFVec2b_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec2b self, SbVec2b value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2b_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec2b self, SoMFVec2b field) -> SbBool"""
        return _coin.SoMFVec2b___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec2b self, SoMFVec2b field) -> SbBool"""
        return _coin.SoMFVec2b___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec2b self) -> SbVec2b"""
        return _coin.SoMFVec2b_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec2b self)"""
        return _coin.SoMFVec2b_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec2b_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec2b in _coin:
_coin.SoMFVec2b_swigregister(SoMFVec2b)
class SoMFVec2s(SoMField):
    r"""Proxy of C++ SoMFVec2s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec2s self) -> SoMFVec2s"""
        _coin.SoMFVec2s_swiginit(self, _coin.new_SoMFVec2s())
    __swig_destroy__ = _coin.delete_SoMFVec2s

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2s_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2s_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec2s self) -> SoType"""
        return _coin.SoMFVec2s_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec2s self, SoField field)"""
        return _coin.SoMFVec2s_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec2s self, SoField field) -> SbBool"""
        return _coin.SoMFVec2s_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec2s self, int const start) -> SbVec2s"""
        return _coin.SoMFVec2s_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec2s self, SbVec2s value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2s_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec2s self, SoMFVec2s field) -> SbBool"""
        return _coin.SoMFVec2s___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec2s self, SoMFVec2s field) -> SbBool"""
        return _coin.SoMFVec2s___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec2s self) -> SbVec2s"""
        return _coin.SoMFVec2s_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec2s self)"""
        return _coin.SoMFVec2s_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec2s_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec2s in _coin:
_coin.SoMFVec2s_swigregister(SoMFVec2s)
class SoMFVec2i32(SoMField):
    r"""Proxy of C++ SoMFVec2i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec2i32 self) -> SoMFVec2i32"""
        _coin.SoMFVec2i32_swiginit(self, _coin.new_SoMFVec2i32())
    __swig_destroy__ = _coin.delete_SoMFVec2i32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2i32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2i32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec2i32 self) -> SoType"""
        return _coin.SoMFVec2i32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec2i32 self, SoField field)"""
        return _coin.SoMFVec2i32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec2i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec2i32_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec2i32 self, int const start) -> SbVec2i32"""
        return _coin.SoMFVec2i32_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec2i32 self, SbVec2i32 value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2i32_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec2i32 self, SoMFVec2i32 field) -> SbBool"""
        return _coin.SoMFVec2i32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec2i32 self, SoMFVec2i32 field) -> SbBool"""
        return _coin.SoMFVec2i32___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec2i32 self) -> SbVec2i32"""
        return _coin.SoMFVec2i32_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec2i32 self)"""
        return _coin.SoMFVec2i32_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec2i32_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec2i32 in _coin:
_coin.SoMFVec2i32_swigregister(SoMFVec2i32)
class SoMFVec2d(SoMField):
    r"""Proxy of C++ SoMFVec2d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec2d self) -> SoMFVec2d"""
        _coin.SoMFVec2d_swiginit(self, _coin.new_SoMFVec2d())
    __swig_destroy__ = _coin.delete_SoMFVec2d

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec2d_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec2d_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec2d self) -> SoType"""
        return _coin.SoMFVec2d_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec2d self, SoField field)"""
        return _coin.SoMFVec2d_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec2d self, SoField field) -> SbBool"""
        return _coin.SoMFVec2d_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec2d self, int const start) -> SbVec2d"""
        return _coin.SoMFVec2d_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec2d self, SbVec2d value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec2d_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec2d self, SoMFVec2d field) -> SbBool"""
        return _coin.SoMFVec2d___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec2d self, SoMFVec2d field) -> SbBool"""
        return _coin.SoMFVec2d___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec2d self) -> SbVec2d"""
        return _coin.SoMFVec2d_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec2d self)"""
        return _coin.SoMFVec2d_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec2d_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec2d in _coin:
_coin.SoMFVec2d_swigregister(SoMFVec2d)
class SoMFVec3b(SoMField):
    r"""Proxy of C++ SoMFVec3b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec3b self) -> SoMFVec3b"""
        _coin.SoMFVec3b_swiginit(self, _coin.new_SoMFVec3b())
    __swig_destroy__ = _coin.delete_SoMFVec3b

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3b_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3b_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec3b self) -> SoType"""
        return _coin.SoMFVec3b_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec3b self, SoField field)"""
        return _coin.SoMFVec3b_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec3b self, SoField field) -> SbBool"""
        return _coin.SoMFVec3b_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec3b self, int const start) -> SbVec3b"""
        return _coin.SoMFVec3b_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec3b self, SbVec3b value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3b_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec3b self, SoMFVec3b field) -> SbBool"""
        return _coin.SoMFVec3b___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec3b self, SoMFVec3b field) -> SbBool"""
        return _coin.SoMFVec3b___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec3b self) -> SbVec3b"""
        return _coin.SoMFVec3b_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec3b self)"""
        return _coin.SoMFVec3b_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec3b_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec3b in _coin:
_coin.SoMFVec3b_swigregister(SoMFVec3b)
class SoMFVec3s(SoMField):
    r"""Proxy of C++ SoMFVec3s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec3s self) -> SoMFVec3s"""
        _coin.SoMFVec3s_swiginit(self, _coin.new_SoMFVec3s())
    __swig_destroy__ = _coin.delete_SoMFVec3s

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3s_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3s_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec3s self) -> SoType"""
        return _coin.SoMFVec3s_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec3s self, SoField field)"""
        return _coin.SoMFVec3s_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec3s self, SoField field) -> SbBool"""
        return _coin.SoMFVec3s_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec3s self, int const start) -> SbVec3s"""
        return _coin.SoMFVec3s_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec3s self, SbVec3s value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3s_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec3s self, SoMFVec3s field) -> SbBool"""
        return _coin.SoMFVec3s___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec3s self, SoMFVec3s field) -> SbBool"""
        return _coin.SoMFVec3s___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec3s self) -> SbVec3s"""
        return _coin.SoMFVec3s_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec3s self)"""
        return _coin.SoMFVec3s_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec3s_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec3s in _coin:
_coin.SoMFVec3s_swigregister(SoMFVec3s)
class SoMFVec3i32(SoMField):
    r"""Proxy of C++ SoMFVec3i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec3i32 self) -> SoMFVec3i32"""
        _coin.SoMFVec3i32_swiginit(self, _coin.new_SoMFVec3i32())
    __swig_destroy__ = _coin.delete_SoMFVec3i32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3i32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3i32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec3i32 self) -> SoType"""
        return _coin.SoMFVec3i32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec3i32 self, SoField field)"""
        return _coin.SoMFVec3i32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec3i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec3i32_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec3i32 self, int const start) -> SbVec3i32"""
        return _coin.SoMFVec3i32_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec3i32 self, SbVec3i32 value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3i32_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec3i32 self, SoMFVec3i32 field) -> SbBool"""
        return _coin.SoMFVec3i32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec3i32 self, SoMFVec3i32 field) -> SbBool"""
        return _coin.SoMFVec3i32___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec3i32 self) -> SbVec3i32"""
        return _coin.SoMFVec3i32_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec3i32 self)"""
        return _coin.SoMFVec3i32_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec3i32_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec3i32 in _coin:
_coin.SoMFVec3i32_swigregister(SoMFVec3i32)
class SoMFVec3d(SoMField):
    r"""Proxy of C++ SoMFVec3d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec3d self) -> SoMFVec3d"""
        _coin.SoMFVec3d_swiginit(self, _coin.new_SoMFVec3d())
    __swig_destroy__ = _coin.delete_SoMFVec3d

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec3d_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec3d_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec3d self) -> SoType"""
        return _coin.SoMFVec3d_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec3d self, SoField field)"""
        return _coin.SoMFVec3d_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec3d self, SoField field) -> SbBool"""
        return _coin.SoMFVec3d_isSame(self, field)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec3d self, SbVec3d value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec3d_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec3d self, SoMFVec3d field) -> SbBool"""
        return _coin.SoMFVec3d___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec3d self, SoMFVec3d field) -> SbBool"""
        return _coin.SoMFVec3d___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec3d self) -> SbVec3d"""
        return _coin.SoMFVec3d_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec3d self)"""
        return _coin.SoMFVec3d_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec3d_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):
        r"""
        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):
        r"""__getitem__(SoMFVec3d self, int i) -> SbVec3d"""
        return _coin.SoMFVec3d___getitem__(self, i)

    def __setitem__(self, i, value):
        r"""__setitem__(SoMFVec3d self, int i, SbVec3d value)"""
        return _coin.SoMFVec3d___setitem__(self, i, value)

    def setValue(self, *args):
        r"""
        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):
        r"""getValues(SoMFVec3d self, int i=0) -> SbVec3d"""
        return _coin.SoMFVec3d_getValues(self, i)

# Register SoMFVec3d in _coin:
_coin.SoMFVec3d_swigregister(SoMFVec3d)
class SoMFVec4b(SoMField):
    r"""Proxy of C++ SoMFVec4b class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec4b self) -> SoMFVec4b"""
        _coin.SoMFVec4b_swiginit(self, _coin.new_SoMFVec4b())
    __swig_destroy__ = _coin.delete_SoMFVec4b

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4b_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4b_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec4b self) -> SoType"""
        return _coin.SoMFVec4b_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec4b self, SoField field)"""
        return _coin.SoMFVec4b_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec4b self, SoField field) -> SbBool"""
        return _coin.SoMFVec4b_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec4b self, int const start) -> SbVec4b"""
        return _coin.SoMFVec4b_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec4b self, SbVec4b value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4b_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec4b self, SoMFVec4b field) -> SbBool"""
        return _coin.SoMFVec4b___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec4b self, SoMFVec4b field) -> SbBool"""
        return _coin.SoMFVec4b___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec4b self) -> SbVec4b"""
        return _coin.SoMFVec4b_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec4b self)"""
        return _coin.SoMFVec4b_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec4b_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec4b in _coin:
_coin.SoMFVec4b_swigregister(SoMFVec4b)
class SoMFVec4ub(SoMField):
    r"""Proxy of C++ SoMFVec4ub class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec4ub self) -> SoMFVec4ub"""
        _coin.SoMFVec4ub_swiginit(self, _coin.new_SoMFVec4ub())
    __swig_destroy__ = _coin.delete_SoMFVec4ub

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4ub_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4ub_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec4ub self) -> SoType"""
        return _coin.SoMFVec4ub_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec4ub self, SoField field)"""
        return _coin.SoMFVec4ub_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec4ub self, SoField field) -> SbBool"""
        return _coin.SoMFVec4ub_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec4ub self, int const start) -> SbVec4ub"""
        return _coin.SoMFVec4ub_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec4ub self, SbVec4ub value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4ub_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec4ub self, SoMFVec4ub field) -> SbBool"""
        return _coin.SoMFVec4ub___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec4ub self, SoMFVec4ub field) -> SbBool"""
        return _coin.SoMFVec4ub___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec4ub self) -> SbVec4ub"""
        return _coin.SoMFVec4ub_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec4ub self)"""
        return _coin.SoMFVec4ub_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec4ub_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec4ub in _coin:
_coin.SoMFVec4ub_swigregister(SoMFVec4ub)
class SoMFVec4s(SoMField):
    r"""Proxy of C++ SoMFVec4s class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec4s self) -> SoMFVec4s"""
        _coin.SoMFVec4s_swiginit(self, _coin.new_SoMFVec4s())
    __swig_destroy__ = _coin.delete_SoMFVec4s

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4s_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4s_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec4s self) -> SoType"""
        return _coin.SoMFVec4s_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec4s self, SoField field)"""
        return _coin.SoMFVec4s_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec4s self, SoField field) -> SbBool"""
        return _coin.SoMFVec4s_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec4s self, int const start) -> SbVec4s"""
        return _coin.SoMFVec4s_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec4s self, SbVec4s value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4s_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec4s self, SoMFVec4s field) -> SbBool"""
        return _coin.SoMFVec4s___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec4s self, SoMFVec4s field) -> SbBool"""
        return _coin.SoMFVec4s___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec4s self) -> SbVec4s"""
        return _coin.SoMFVec4s_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec4s self)"""
        return _coin.SoMFVec4s_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec4s_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec4s in _coin:
_coin.SoMFVec4s_swigregister(SoMFVec4s)
class SoMFVec4us(SoMField):
    r"""Proxy of C++ SoMFVec4us class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec4us self) -> SoMFVec4us"""
        _coin.SoMFVec4us_swiginit(self, _coin.new_SoMFVec4us())
    __swig_destroy__ = _coin.delete_SoMFVec4us

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4us_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4us_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec4us self) -> SoType"""
        return _coin.SoMFVec4us_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec4us self, SoField field)"""
        return _coin.SoMFVec4us_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec4us self, SoField field) -> SbBool"""
        return _coin.SoMFVec4us_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec4us self, int const start) -> SbVec4us"""
        return _coin.SoMFVec4us_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec4us self, SbVec4us value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4us_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec4us self, SoMFVec4us field) -> SbBool"""
        return _coin.SoMFVec4us___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec4us self, SoMFVec4us field) -> SbBool"""
        return _coin.SoMFVec4us___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec4us self) -> SbVec4us"""
        return _coin.SoMFVec4us_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec4us self)"""
        return _coin.SoMFVec4us_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec4us_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec4us in _coin:
_coin.SoMFVec4us_swigregister(SoMFVec4us)
class SoMFVec4i32(SoMField):
    r"""Proxy of C++ SoMFVec4i32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec4i32 self) -> SoMFVec4i32"""
        _coin.SoMFVec4i32_swiginit(self, _coin.new_SoMFVec4i32())
    __swig_destroy__ = _coin.delete_SoMFVec4i32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4i32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4i32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec4i32 self) -> SoType"""
        return _coin.SoMFVec4i32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec4i32 self, SoField field)"""
        return _coin.SoMFVec4i32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec4i32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec4i32_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec4i32 self, int const start) -> SbVec4i32"""
        return _coin.SoMFVec4i32_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec4i32 self, SbVec4i32 value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4i32_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec4i32 self, SoMFVec4i32 field) -> SbBool"""
        return _coin.SoMFVec4i32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec4i32 self, SoMFVec4i32 field) -> SbBool"""
        return _coin.SoMFVec4i32___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec4i32 self) -> SbVec4i32"""
        return _coin.SoMFVec4i32_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec4i32 self)"""
        return _coin.SoMFVec4i32_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec4i32_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec4i32 in _coin:
_coin.SoMFVec4i32_swigregister(SoMFVec4i32)
class SoMFVec4ui32(SoMField):
    r"""Proxy of C++ SoMFVec4ui32 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec4ui32 self) -> SoMFVec4ui32"""
        _coin.SoMFVec4ui32_swiginit(self, _coin.new_SoMFVec4ui32())
    __swig_destroy__ = _coin.delete_SoMFVec4ui32

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4ui32_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4ui32_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec4ui32 self) -> SoType"""
        return _coin.SoMFVec4ui32_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec4ui32 self, SoField field)"""
        return _coin.SoMFVec4ui32_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec4ui32 self, SoField field) -> SbBool"""
        return _coin.SoMFVec4ui32_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec4ui32 self, int const start) -> SbVec4ui32"""
        return _coin.SoMFVec4ui32_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec4ui32 self, SbVec4ui32 value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4ui32_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec4ui32 self, SoMFVec4ui32 field) -> SbBool"""
        return _coin.SoMFVec4ui32___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec4ui32 self, SoMFVec4ui32 field) -> SbBool"""
        return _coin.SoMFVec4ui32___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec4ui32 self) -> SbVec4ui32"""
        return _coin.SoMFVec4ui32_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec4ui32 self)"""
        return _coin.SoMFVec4ui32_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec4ui32_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec4ui32 in _coin:
_coin.SoMFVec4ui32_swigregister(SoMFVec4ui32)
class SoMFVec4d(SoMField):
    r"""Proxy of C++ SoMFVec4d class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoMFVec4d self) -> SoMFVec4d"""
        _coin.SoMFVec4d_swiginit(self, _coin.new_SoMFVec4d())
    __swig_destroy__ = _coin.delete_SoMFVec4d

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoMFVec4d_createInstance()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMFVec4d_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMFVec4d self) -> SoType"""
        return _coin.SoMFVec4d_getTypeId(self)

    def copyFrom(self, field):
        r"""copyFrom(SoMFVec4d self, SoField field)"""
        return _coin.SoMFVec4d_copyFrom(self, field)

    def isSame(self, field):
        r"""isSame(SoMFVec4d self, SoField field) -> SbBool"""
        return _coin.SoMFVec4d_isSame(self, field)

    def getValues(self, start):
        r"""getValues(SoMFVec4d self, int const start) -> SbVec4d"""
        return _coin.SoMFVec4d_getValues(self, start)

    def find(self, value, addifnotfound=0):
        r"""find(SoMFVec4d self, SbVec4d value, SbBool addifnotfound=0) -> int"""
        return _coin.SoMFVec4d_find(self, value, addifnotfound)

    def __eq__(self, field):
        r"""__eq__(SoMFVec4d self, SoMFVec4d field) -> SbBool"""
        return _coin.SoMFVec4d___eq__(self, field)

    def __ne__(self, field):
        r"""__ne__(SoMFVec4d self, SoMFVec4d field) -> SbBool"""
        return _coin.SoMFVec4d___ne__(self, field)

    def startEditing(self):
        r"""startEditing(SoMFVec4d self) -> SbVec4d"""
        return _coin.SoMFVec4d_startEditing(self)

    def finishEditing(self):
        r"""finishEditing(SoMFVec4d self)"""
        return _coin.SoMFVec4d_finishEditing(self)

    def setValuesPointer(self, *args):
        r"""
        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)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMFVec4d_initClass()

    def setValues(self, *args):
        r"""
        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):
        r"""
        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):
        r"""
        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)

# Register SoMFVec4d in _coin:
_coin.SoMFVec4d_swigregister(SoMFVec4d)
class SbStringList(SbPList):
    r"""Proxy of C++ SbStringList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbStringList self) -> SbStringList
        __init__(SbStringList self, int const sizehint) -> SbStringList
        """
        _coin.SbStringList_swiginit(self, _coin.new_SbStringList(*args))

    def append(self, string):
        r"""append(SbStringList self, SbString string)"""
        return _coin.SbStringList_append(self, string)

    def find(self, string):
        r"""find(SbStringList self, SbString string) -> int"""
        return _coin.SbStringList_find(self, string)

    def insert(self, string, insertbefore):
        r"""insert(SbStringList self, SbString string, int insertbefore)"""
        return _coin.SbStringList_insert(self, string, insertbefore)

    def getArrayPtr(self):
        r"""getArrayPtr(SbStringList self) -> SbString const **"""
        return _coin.SbStringList_getArrayPtr(self)

    def __setitem__(self, i, value):
        r"""__setitem__(SbStringList self, int const i, SbString value)"""
        return _coin.SbStringList___setitem__(self, i, value)

    def __getitem__(self, i):
        r"""__getitem__(SbStringList self, int i) -> SbString"""
        return _coin.SbStringList___getitem__(self, i)

    def get(self, i):
        r"""get(SbStringList self, int const i) -> SbString"""
        return _coin.SbStringList_get(self, i)
    __swig_destroy__ = _coin.delete_SbStringList

# Register SbStringList in _coin:
_coin.SbStringList_swigregister(SbStringList)
class SbVec3fList(SbPList):
    r"""Proxy of C++ SbVec3fList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SbVec3fList self) -> SbVec3fList"""
        _coin.SbVec3fList_swiginit(self, _coin.new_SbVec3fList())
    __swig_destroy__ = _coin.delete_SbVec3fList

    def append(self, item):
        r"""append(SbVec3fList self, SbVec3f item)"""
        return _coin.SbVec3fList_append(self, item)

    def insert(self, item, insertbefore):
        r"""insert(SbVec3fList self, SbVec3f item, int const insertbefore)"""
        return _coin.SbVec3fList_insert(self, item, insertbefore)

    def __setitem__(self, i, value):
        r"""__setitem__(SbVec3fList self, int const i, SbVec3f value)"""
        return _coin.SbVec3fList___setitem__(self, i, value)

    def __getitem__(self, i):
        r"""__getitem__(SbVec3fList self, int i) -> SbVec3f"""
        return _coin.SbVec3fList___getitem__(self, i)

    def get(self, i):
        r"""get(SbVec3fList self, int const i) -> SbVec3f"""
        return _coin.SbVec3fList_get(self, i)

# Register SbVec3fList in _coin:
_coin.SbVec3fList_swigregister(SbVec3fList)
class SoLockManager(object):
    r"""Proxy of C++ SoLockManager class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def SetUnlockString(unlockstr):
        r"""SetUnlockString(char * unlockstr)"""
        return _coin.SoLockManager_SetUnlockString(unlockstr)

    @staticmethod
    def GetUnlockString():
        r"""GetUnlockString() -> char *"""
        return _coin.SoLockManager_GetUnlockString()

    def __init__(self):
        r"""__init__(SoLockManager self) -> SoLockManager"""
        _coin.SoLockManager_swiginit(self, _coin.new_SoLockManager())
    __swig_destroy__ = _coin.delete_SoLockManager

# Register SoLockManager in _coin:
_coin.SoLockManager_swigregister(SoLockManager)
class SoTransform(SoTransformation):
    r"""Proxy of C++ SoTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransform self) -> SoType"""
        return _coin.SoTransform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransform_initClass()

    def __init__(self):
        r"""__init__(SoTransform self) -> SoTransform"""
        _coin.SoTransform_swiginit(self, _coin.new_SoTransform())
    translation = property(_coin.SoTransform_translation_get, _coin.SoTransform_translation_set, doc=r"""translation : SoSFVec3f""")
    rotation = property(_coin.SoTransform_rotation_get, _coin.SoTransform_rotation_set, doc=r"""rotation : SoSFRotation""")
    scaleFactor = property(_coin.SoTransform_scaleFactor_get, _coin.SoTransform_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")
    scaleOrientation = property(_coin.SoTransform_scaleOrientation_get, _coin.SoTransform_scaleOrientation_set, doc=r"""scaleOrientation : SoSFRotation""")
    center = property(_coin.SoTransform_center_get, _coin.SoTransform_center_set, doc=r"""center : SoSFVec3f""")

    def pointAt(self, frompoint, topoint):
        r"""pointAt(SoTransform self, SbVec3f frompoint, SbVec3f topoint)"""
        return _coin.SoTransform_pointAt(self, frompoint, topoint)

    def getScaleSpaceMatrix(self, mat, inv):
        r"""getScaleSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getScaleSpaceMatrix(self, mat, inv)

    def getRotationSpaceMatrix(self, mat, inv):
        r"""getRotationSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getRotationSpaceMatrix(self, mat, inv)

    def getTranslationSpaceMatrix(self, mat, inv):
        r"""getTranslationSpaceMatrix(SoTransform self, SbMatrix mat, SbMatrix inv)"""
        return _coin.SoTransform_getTranslationSpaceMatrix(self, mat, inv)

    def multLeft(self, mat):
        r"""multLeft(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_multLeft(self, mat)

    def multRight(self, mat):
        r"""multRight(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_multRight(self, mat)

    def combineLeft(self, nodeonright):
        r"""combineLeft(SoTransform self, SoTransformation nodeonright)"""
        return _coin.SoTransform_combineLeft(self, nodeonright)

    def combineRight(self, nodeonleft):
        r"""combineRight(SoTransform self, SoTransformation nodeonleft)"""
        return _coin.SoTransform_combineRight(self, nodeonleft)

    def setMatrix(self, mat):
        r"""setMatrix(SoTransform self, SbMatrix mat)"""
        return _coin.SoTransform_setMatrix(self, mat)

    def recenter(self, newcenter):
        r"""recenter(SoTransform self, SbVec3f newcenter)"""
        return _coin.SoTransform_recenter(self, newcenter)

    def doAction(self, action):
        r"""doAction(SoTransform self, SoAction action)"""
        return _coin.SoTransform_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTransform self, SoGLRenderAction action)"""
        return _coin.SoTransform_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTransform self, SoCallbackAction action)"""
        return _coin.SoTransform_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransform_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoTransform self, SoGetMatrixAction action)"""
        return _coin.SoTransform_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoTransform self, SoPickAction action)"""
        return _coin.SoTransform_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTransform_getPrimitiveCount(self, action)

# Register SoTransform in _coin:
_coin.SoTransform_swigregister(SoTransform)
class SoTransformManip(SoTransform):
    r"""Proxy of C++ SoTransformManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransformManip self) -> SoType"""
        return _coin.SoTransformManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransformManip_initClass()

    def __init__(self):
        r"""__init__(SoTransformManip self) -> SoTransformManip"""
        _coin.SoTransformManip_swiginit(self, _coin.new_SoTransformManip())

    def getDragger(self):
        r"""getDragger(SoTransformManip self) -> SoDragger"""
        return _coin.SoTransformManip_getDragger(self)

    def replaceNode(self, p):
        r"""replaceNode(SoTransformManip self, SoPath p) -> SbBool"""
        return _coin.SoTransformManip_replaceNode(self, p)

    def replaceManip(self, p, newone):
        r"""replaceManip(SoTransformManip self, SoPath p, SoTransform newone) -> SbBool"""
        return _coin.SoTransformManip_replaceManip(self, p, newone)

    def doAction(self, action):
        r"""doAction(SoTransformManip self, SoAction action)"""
        return _coin.SoTransformManip_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTransformManip self, SoCallbackAction action)"""
        return _coin.SoTransformManip_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTransformManip self, SoGLRenderAction action)"""
        return _coin.SoTransformManip_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoTransformManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransformManip_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoTransformManip self, SoGetMatrixAction action)"""
        return _coin.SoTransformManip_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoTransformManip self, SoHandleEventAction action)"""
        return _coin.SoTransformManip_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoTransformManip self, SoPickAction action)"""
        return _coin.SoTransformManip_pick(self, action)

    def search(self, action):
        r"""search(SoTransformManip self, SoSearchAction action)"""
        return _coin.SoTransformManip_search(self, action)

    def getChildren(self):
        r"""getChildren(SoTransformManip self) -> SoChildList"""
        return _coin.SoTransformManip_getChildren(self)

# Register SoTransformManip in _coin:
_coin.SoTransformManip_swigregister(SoTransformManip)
class SoCenterballManip(SoTransformManip):
    r"""Proxy of C++ SoCenterballManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCenterballManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCenterballManip self) -> SoType"""
        return _coin.SoCenterballManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCenterballManip_initClass()

    def __init__(self):
        r"""__init__(SoCenterballManip self) -> SoCenterballManip"""
        _coin.SoCenterballManip_swiginit(self, _coin.new_SoCenterballManip())

# Register SoCenterballManip in _coin:
_coin.SoCenterballManip_swigregister(SoCenterballManip)
class SoClipPlane(SoNode):
    r"""Proxy of C++ SoClipPlane class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoClipPlane_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoClipPlane self) -> SoType"""
        return _coin.SoClipPlane_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoClipPlane_initClass()

    def __init__(self):
        r"""__init__(SoClipPlane self) -> SoClipPlane"""
        _coin.SoClipPlane_swiginit(self, _coin.new_SoClipPlane())
    plane = property(_coin.SoClipPlane_plane_get, _coin.SoClipPlane_plane_set, doc=r"""plane : SoSFPlane""")
    on = property(_coin.SoClipPlane_on_get, _coin.SoClipPlane_on_set, doc=r"""on : SoSFBool""")

    def doAction(self, action):
        r"""doAction(SoClipPlane self, SoAction action)"""
        return _coin.SoClipPlane_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoClipPlane self, SoGLRenderAction action)"""
        return _coin.SoClipPlane_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoClipPlane self, SoCallbackAction action)"""
        return _coin.SoClipPlane_callback(self, action)

    def pick(self, action):
        r"""pick(SoClipPlane self, SoPickAction action)"""
        return _coin.SoClipPlane_pick(self, action)

# Register SoClipPlane in _coin:
_coin.SoClipPlane_swigregister(SoClipPlane)
class SoClipPlaneManip(SoClipPlane):
    r"""Proxy of C++ SoClipPlaneManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoClipPlaneManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoClipPlaneManip self) -> SoType"""
        return _coin.SoClipPlaneManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoClipPlaneManip_initClass()

    def __init__(self):
        r"""__init__(SoClipPlaneManip self) -> SoClipPlaneManip"""
        _coin.SoClipPlaneManip_swiginit(self, _coin.new_SoClipPlaneManip())

    def getDragger(self):
        r"""getDragger(SoClipPlaneManip self) -> SoDragger"""
        return _coin.SoClipPlaneManip_getDragger(self)

    def setValue(self, box, planenormal, draggerscalefactor):
        r"""setValue(SoClipPlaneManip self, SbBox3f box, SbVec3f planenormal, float draggerscalefactor)"""
        return _coin.SoClipPlaneManip_setValue(self, box, planenormal, draggerscalefactor)

    def replaceNode(self, p):
        r"""replaceNode(SoClipPlaneManip self, SoPath p) -> SbBool"""
        return _coin.SoClipPlaneManip_replaceNode(self, p)

    def replaceManip(self, p, newone):
        r"""replaceManip(SoClipPlaneManip self, SoPath p, SoClipPlane newone) -> SbBool"""
        return _coin.SoClipPlaneManip_replaceManip(self, p, newone)

    def doAction(self, action):
        r"""doAction(SoClipPlaneManip self, SoAction action)"""
        return _coin.SoClipPlaneManip_doAction(self, action)

    def callback(self, action):
        r"""callback(SoClipPlaneManip self, SoCallbackAction action)"""
        return _coin.SoClipPlaneManip_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoClipPlaneManip self, SoGLRenderAction action)"""
        return _coin.SoClipPlaneManip_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoClipPlaneManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoClipPlaneManip_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoClipPlaneManip self, SoGetMatrixAction action)"""
        return _coin.SoClipPlaneManip_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoClipPlaneManip self, SoHandleEventAction action)"""
        return _coin.SoClipPlaneManip_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoClipPlaneManip self, SoPickAction action)"""
        return _coin.SoClipPlaneManip_pick(self, action)

    def search(self, action):
        r"""search(SoClipPlaneManip self, SoSearchAction action)"""
        return _coin.SoClipPlaneManip_search(self, action)

    def getChildren(self):
        r"""getChildren(SoClipPlaneManip self) -> SoChildList"""
        return _coin.SoClipPlaneManip_getChildren(self)
    draggerPosition = property(_coin.SoClipPlaneManip_draggerPosition_get, _coin.SoClipPlaneManip_draggerPosition_set, doc=r"""draggerPosition : SoSFVec3f""")

# Register SoClipPlaneManip in _coin:
_coin.SoClipPlaneManip_swigregister(SoClipPlaneManip)
class SoLight(SoNode):
    r"""Proxy of C++ SoLight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLight self) -> SoType"""
        return _coin.SoLight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLight_initClass()
    on = property(_coin.SoLight_on_get, _coin.SoLight_on_set, doc=r"""on : SoSFBool""")
    intensity = property(_coin.SoLight_intensity_get, _coin.SoLight_intensity_set, doc=r"""intensity : SoSFFloat""")
    color = property(_coin.SoLight_color_get, _coin.SoLight_color_set, doc=r"""color : SoSFColor""")

    def callback(self, action):
        r"""callback(SoLight self, SoCallbackAction action)"""
        return _coin.SoLight_callback(self, action)

# Register SoLight in _coin:
_coin.SoLight_swigregister(SoLight)
class SoDirectionalLight(SoLight):
    r"""Proxy of C++ SoDirectionalLight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDirectionalLight self) -> SoType"""
        return _coin.SoDirectionalLight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDirectionalLight_initClass()

    def __init__(self):
        r"""__init__(SoDirectionalLight self) -> SoDirectionalLight"""
        _coin.SoDirectionalLight_swiginit(self, _coin.new_SoDirectionalLight())
    direction = property(_coin.SoDirectionalLight_direction_get, _coin.SoDirectionalLight_direction_set, doc=r"""direction : SoSFVec3f""")

    def GLRender(self, action):
        r"""GLRender(SoDirectionalLight self, SoGLRenderAction action)"""
        return _coin.SoDirectionalLight_GLRender(self, action)

# Register SoDirectionalLight in _coin:
_coin.SoDirectionalLight_swigregister(SoDirectionalLight)
class SoDirectionalLightManip(SoDirectionalLight):
    r"""Proxy of C++ SoDirectionalLightManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDirectionalLightManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDirectionalLightManip self) -> SoType"""
        return _coin.SoDirectionalLightManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDirectionalLightManip_initClass()

    def __init__(self):
        r"""__init__(SoDirectionalLightManip self) -> SoDirectionalLightManip"""
        _coin.SoDirectionalLightManip_swiginit(self, _coin.new_SoDirectionalLightManip())

    def getDragger(self):
        r"""getDragger(SoDirectionalLightManip self) -> SoDragger"""
        return _coin.SoDirectionalLightManip_getDragger(self)

    def replaceNode(self, path):
        r"""replaceNode(SoDirectionalLightManip self, SoPath path) -> SbBool"""
        return _coin.SoDirectionalLightManip_replaceNode(self, path)

    def replaceManip(self, path, newone):
        r"""replaceManip(SoDirectionalLightManip self, SoPath path, SoDirectionalLight newone) -> SbBool"""
        return _coin.SoDirectionalLightManip_replaceManip(self, path, newone)

    def doAction(self, action):
        r"""doAction(SoDirectionalLightManip self, SoAction action)"""
        return _coin.SoDirectionalLightManip_doAction(self, action)

    def callback(self, action):
        r"""callback(SoDirectionalLightManip self, SoCallbackAction action)"""
        return _coin.SoDirectionalLightManip_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoDirectionalLightManip self, SoGLRenderAction action)"""
        return _coin.SoDirectionalLightManip_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoDirectionalLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoDirectionalLightManip_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoDirectionalLightManip self, SoGetMatrixAction action)"""
        return _coin.SoDirectionalLightManip_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoDirectionalLightManip self, SoHandleEventAction action)"""
        return _coin.SoDirectionalLightManip_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoDirectionalLightManip self, SoPickAction action)"""
        return _coin.SoDirectionalLightManip_pick(self, action)

    def search(self, action):
        r"""search(SoDirectionalLightManip self, SoSearchAction action)"""
        return _coin.SoDirectionalLightManip_search(self, action)

    def getChildren(self):
        r"""getChildren(SoDirectionalLightManip self) -> SoChildList"""
        return _coin.SoDirectionalLightManip_getChildren(self)

# Register SoDirectionalLightManip in _coin:
_coin.SoDirectionalLightManip_swigregister(SoDirectionalLightManip)
class SoHandleBoxManip(SoTransformManip):
    r"""Proxy of C++ SoHandleBoxManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoHandleBoxManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoHandleBoxManip self) -> SoType"""
        return _coin.SoHandleBoxManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoHandleBoxManip_initClass()

    def __init__(self):
        r"""__init__(SoHandleBoxManip self) -> SoHandleBoxManip"""
        _coin.SoHandleBoxManip_swiginit(self, _coin.new_SoHandleBoxManip())

# Register SoHandleBoxManip in _coin:
_coin.SoHandleBoxManip_swigregister(SoHandleBoxManip)
class SoJackManip(SoTransformManip):
    r"""Proxy of C++ SoJackManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoJackManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoJackManip self) -> SoType"""
        return _coin.SoJackManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoJackManip_initClass()

    def __init__(self):
        r"""__init__(SoJackManip self) -> SoJackManip"""
        _coin.SoJackManip_swiginit(self, _coin.new_SoJackManip())

# Register SoJackManip in _coin:
_coin.SoJackManip_swigregister(SoJackManip)
class SoPointLight(SoLight):
    r"""Proxy of C++ SoPointLight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointLight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPointLight self) -> SoType"""
        return _coin.SoPointLight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPointLight_initClass()

    def __init__(self):
        r"""__init__(SoPointLight self) -> SoPointLight"""
        _coin.SoPointLight_swiginit(self, _coin.new_SoPointLight())
    location = property(_coin.SoPointLight_location_get, _coin.SoPointLight_location_set, doc=r"""location : SoSFVec3f""")

    def GLRender(self, action):
        r"""GLRender(SoPointLight self, SoGLRenderAction action)"""
        return _coin.SoPointLight_GLRender(self, action)

# Register SoPointLight in _coin:
_coin.SoPointLight_swigregister(SoPointLight)
class SoPointLightManip(SoPointLight):
    r"""Proxy of C++ SoPointLightManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointLightManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPointLightManip self) -> SoType"""
        return _coin.SoPointLightManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPointLightManip_initClass()

    def __init__(self):
        r"""__init__(SoPointLightManip self) -> SoPointLightManip"""
        _coin.SoPointLightManip_swiginit(self, _coin.new_SoPointLightManip())

    def getDragger(self):
        r"""getDragger(SoPointLightManip self) -> SoDragger"""
        return _coin.SoPointLightManip_getDragger(self)

    def replaceNode(self, path):
        r"""replaceNode(SoPointLightManip self, SoPath path) -> SbBool"""
        return _coin.SoPointLightManip_replaceNode(self, path)

    def replaceManip(self, path, newone):
        r"""replaceManip(SoPointLightManip self, SoPath path, SoPointLight newone) -> SbBool"""
        return _coin.SoPointLightManip_replaceManip(self, path, newone)

    def doAction(self, action):
        r"""doAction(SoPointLightManip self, SoAction action)"""
        return _coin.SoPointLightManip_doAction(self, action)

    def callback(self, action):
        r"""callback(SoPointLightManip self, SoCallbackAction action)"""
        return _coin.SoPointLightManip_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoPointLightManip self, SoGLRenderAction action)"""
        return _coin.SoPointLightManip_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoPointLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoPointLightManip_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoPointLightManip self, SoGetMatrixAction action)"""
        return _coin.SoPointLightManip_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoPointLightManip self, SoHandleEventAction action)"""
        return _coin.SoPointLightManip_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoPointLightManip self, SoPickAction action)"""
        return _coin.SoPointLightManip_pick(self, action)

    def search(self, action):
        r"""search(SoPointLightManip self, SoSearchAction action)"""
        return _coin.SoPointLightManip_search(self, action)

    def getChildren(self):
        r"""getChildren(SoPointLightManip self) -> SoChildList"""
        return _coin.SoPointLightManip_getChildren(self)

# Register SoPointLightManip in _coin:
_coin.SoPointLightManip_swigregister(SoPointLightManip)
class SoSpotLight(SoLight):
    r"""Proxy of C++ SoSpotLight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpotLight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSpotLight self) -> SoType"""
        return _coin.SoSpotLight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSpotLight_initClass()

    def __init__(self):
        r"""__init__(SoSpotLight self) -> SoSpotLight"""
        _coin.SoSpotLight_swiginit(self, _coin.new_SoSpotLight())
    location = property(_coin.SoSpotLight_location_get, _coin.SoSpotLight_location_set, doc=r"""location : SoSFVec3f""")
    direction = property(_coin.SoSpotLight_direction_get, _coin.SoSpotLight_direction_set, doc=r"""direction : SoSFVec3f""")
    dropOffRate = property(_coin.SoSpotLight_dropOffRate_get, _coin.SoSpotLight_dropOffRate_set, doc=r"""dropOffRate : SoSFFloat""")
    cutOffAngle = property(_coin.SoSpotLight_cutOffAngle_get, _coin.SoSpotLight_cutOffAngle_set, doc=r"""cutOffAngle : SoSFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoSpotLight self, SoGLRenderAction action)"""
        return _coin.SoSpotLight_GLRender(self, action)

# Register SoSpotLight in _coin:
_coin.SoSpotLight_swigregister(SoSpotLight)
class SoSpotLightManip(SoSpotLight):
    r"""Proxy of C++ SoSpotLightManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSpotLightManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSpotLightManip self) -> SoType"""
        return _coin.SoSpotLightManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSpotLightManip_initClass()

    def __init__(self):
        r"""__init__(SoSpotLightManip self) -> SoSpotLightManip"""
        _coin.SoSpotLightManip_swiginit(self, _coin.new_SoSpotLightManip())

    def getDragger(self):
        r"""getDragger(SoSpotLightManip self) -> SoDragger"""
        return _coin.SoSpotLightManip_getDragger(self)

    def replaceNode(self, p):
        r"""replaceNode(SoSpotLightManip self, SoPath p) -> SbBool"""
        return _coin.SoSpotLightManip_replaceNode(self, p)

    def replaceManip(self, p, newone):
        r"""replaceManip(SoSpotLightManip self, SoPath p, SoSpotLight newone) -> SbBool"""
        return _coin.SoSpotLightManip_replaceManip(self, p, newone)

    def doAction(self, action):
        r"""doAction(SoSpotLightManip self, SoAction action)"""
        return _coin.SoSpotLightManip_doAction(self, action)

    def callback(self, action):
        r"""callback(SoSpotLightManip self, SoCallbackAction action)"""
        return _coin.SoSpotLightManip_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoSpotLightManip self, SoGLRenderAction action)"""
        return _coin.SoSpotLightManip_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoSpotLightManip self, SoGetBoundingBoxAction action)"""
        return _coin.SoSpotLightManip_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoSpotLightManip self, SoGetMatrixAction action)"""
        return _coin.SoSpotLightManip_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoSpotLightManip self, SoHandleEventAction action)"""
        return _coin.SoSpotLightManip_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoSpotLightManip self, SoPickAction action)"""
        return _coin.SoSpotLightManip_pick(self, action)

    def search(self, action):
        r"""search(SoSpotLightManip self, SoSearchAction action)"""
        return _coin.SoSpotLightManip_search(self, action)

    def getChildren(self):
        r"""getChildren(SoSpotLightManip self) -> SoChildList"""
        return _coin.SoSpotLightManip_getChildren(self)

# Register SoSpotLightManip in _coin:
_coin.SoSpotLightManip_swigregister(SoSpotLightManip)
class SoTabBoxManip(SoTransformManip):
    r"""Proxy of C++ SoTabBoxManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTabBoxManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTabBoxManip self) -> SoType"""
        return _coin.SoTabBoxManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTabBoxManip_initClass()

    def __init__(self):
        r"""__init__(SoTabBoxManip self) -> SoTabBoxManip"""
        _coin.SoTabBoxManip_swiginit(self, _coin.new_SoTabBoxManip())

# Register SoTabBoxManip in _coin:
_coin.SoTabBoxManip_swigregister(SoTabBoxManip)
class SoTrackballManip(SoTransformManip):
    r"""Proxy of C++ SoTrackballManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTrackballManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTrackballManip self) -> SoType"""
        return _coin.SoTrackballManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTrackballManip_initClass()

    def __init__(self):
        r"""__init__(SoTrackballManip self) -> SoTrackballManip"""
        _coin.SoTrackballManip_swiginit(self, _coin.new_SoTrackballManip())

# Register SoTrackballManip in _coin:
_coin.SoTrackballManip_swigregister(SoTrackballManip)
class SoTransformBoxManip(SoTransformManip):
    r"""Proxy of C++ SoTransformBoxManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformBoxManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransformBoxManip self) -> SoType"""
        return _coin.SoTransformBoxManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransformBoxManip_initClass()

    def __init__(self):
        r"""__init__(SoTransformBoxManip self) -> SoTransformBoxManip"""
        _coin.SoTransformBoxManip_swiginit(self, _coin.new_SoTransformBoxManip())

# Register SoTransformBoxManip in _coin:
_coin.SoTransformBoxManip_swigregister(SoTransformBoxManip)
class SoTransformerManip(SoTransformManip):
    r"""Proxy of C++ SoTransformerManip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformerManip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransformerManip self) -> SoType"""
        return _coin.SoTransformerManip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransformerManip_initClass()

    def __init__(self):
        r"""__init__(SoTransformerManip self) -> SoTransformerManip"""
        _coin.SoTransformerManip_swiginit(self, _coin.new_SoTransformerManip())

    def isLocateHighlighting(self):
        r"""isLocateHighlighting(SoTransformerManip self) -> SbBool"""
        return _coin.SoTransformerManip_isLocateHighlighting(self)

    def setLocateHighlighting(self, onoff):
        r"""setLocateHighlighting(SoTransformerManip self, SbBool onoff)"""
        return _coin.SoTransformerManip_setLocateHighlighting(self, onoff)

    def unsquishKnobs(self):
        r"""unsquishKnobs(SoTransformerManip self)"""
        return _coin.SoTransformerManip_unsquishKnobs(self)

# Register SoTransformerManip in _coin:
_coin.SoTransformerManip_swigregister(SoTransformerManip)
class SoAudioDevice(object):
    r"""Proxy of C++ SoAudioDevice class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def instance():
        r"""instance() -> SoAudioDevice"""
        return _coin.SoAudioDevice_instance()

    def init(self, devicetype, devicename):
        r"""init(SoAudioDevice self, SbString devicetype, SbString devicename) -> SbBool"""
        return _coin.SoAudioDevice_init(self, devicetype, devicename)

    def enable(self):
        r"""enable(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_enable(self)

    def disable(self):
        r"""disable(SoAudioDevice self)"""
        return _coin.SoAudioDevice_disable(self)

    def isEnabled(self):
        r"""isEnabled(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_isEnabled(self)

    def haveSound(self):
        r"""haveSound(SoAudioDevice self) -> SbBool"""
        return _coin.SoAudioDevice_haveSound(self)

    def setGain(self, gain):
        r"""setGain(SoAudioDevice self, float gain)"""
        return _coin.SoAudioDevice_setGain(self, gain)

    def mute(self, mute=1):
        r"""mute(SoAudioDevice self, SbBool mute=1)"""
        return _coin.SoAudioDevice_mute(self, mute)

# Register SoAudioDevice in _coin:
_coin.SoAudioDevice_swigregister(SoAudioDevice)
class SoByteStream(object):
    r"""Proxy of C++ SoByteStream class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoByteStream self) -> SoByteStream"""
        _coin.SoByteStream_swiginit(self, _coin.new_SoByteStream())
    __swig_destroy__ = _coin.delete_SoByteStream

    def convert(self, *args):
        r"""
        convert(SoByteStream self, SoNode node, SbBool binary=1)
        convert(SoByteStream self, SoPath path, SbBool binary=1)
        convert(SoByteStream self, SoPathList pl, SbBool binary=1)
        """
        return _coin.SoByteStream_convert(self, *args)

    def getData(self):
        r"""getData(SoByteStream self) -> void *"""
        return _coin.SoByteStream_getData(self)

    def getNumBytes(self):
        r"""getNumBytes(SoByteStream self) -> uint32_t"""
        return _coin.SoByteStream_getNumBytes(self)

    @staticmethod
    def unconvert(*args):
        r"""
        unconvert(SoByteStream stream) -> SoPathList
        unconvert(void * data, uint32_t bytesinstream) -> SoPathList
        """
        return _coin.SoByteStream_unconvert(*args)

    def copy(self, d, len):
        r"""copy(SoByteStream self, void * d, size_t len)"""
        return _coin.SoByteStream_copy(self, d, len)

    def isRawData(self):
        r"""isRawData(SoByteStream self) -> SbBool"""
        return _coin.SoByteStream_isRawData(self)

# Register SoByteStream in _coin:
_coin.SoByteStream_swigregister(SoByteStream)
class SoContextHandler(object):
    r"""Proxy of C++ SoContextHandler class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def destructingContext(contextid):
        r"""destructingContext(uint32_t contextid)"""
        return _coin.SoContextHandler_destructingContext(contextid)

    @staticmethod
    def addContextDestructionCallback(func, closure):
        r"""addContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
        return _coin.SoContextHandler_addContextDestructionCallback(func, closure)

    @staticmethod
    def removeContextDestructionCallback(func, closure):
        r"""removeContextDestructionCallback(SoContextHandler::ContextDestructionCB * func, void * closure)"""
        return _coin.SoContextHandler_removeContextDestructionCallback(func, closure)

    def __init__(self):
        r"""__init__(SoContextHandler self) -> SoContextHandler"""
        _coin.SoContextHandler_swiginit(self, _coin.new_SoContextHandler())
    __swig_destroy__ = _coin.delete_SoContextHandler

# Register SoContextHandler in _coin:
_coin.SoContextHandler_swigregister(SoContextHandler)
class SoGLImage(object):
    r"""Proxy of C++ SoGLImage class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoGLImage self) -> SoGLImage"""
        _coin.SoGLImage_swiginit(self, _coin.new_SoGLImage())

    def unref(self, state=None):
        r"""unref(SoGLImage self, SoState state=None)"""
        return _coin.SoGLImage_unref(self, state)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLImage_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoGLImage self) -> SoType"""
        return _coin.SoGLImage_getTypeId(self)

    def isOfType(self, type):
        r"""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):
        r"""setGLDisplayList(SoGLImage self, SoGLDisplayList dl, SoState state, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5)"""
        return _coin.SoGLImage_setGLDisplayList(self, *args)

    def setPBuffer(self, *args):
        r"""setPBuffer(SoGLImage self, SoState state, void * context, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, float const quality=0.5)"""
        return _coin.SoGLImage_setPBuffer(self, *args)

    def setData(self, *args):
        r"""
        setData(SoGLImage self, unsigned char const * bytes, SbVec2s size, int const numcomponents, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, 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=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, SoGLImage::Wrap const wrapr=REPEAT, float const quality=0.5, int const border=0, SoState createinstate=None)
        setData(SoGLImage self, SbImage image, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, 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, SoState createinstate=None)
        """
        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):
        r"""setFlags(SoGLImage self, uint32_t const flags)"""
        return _coin.SoGLImage_setFlags(self, flags)

    def getFlags(self):
        r"""getFlags(SoGLImage self) -> uint32_t"""
        return _coin.SoGLImage_getFlags(self)

    def getImage(self):
        r"""getImage(SoGLImage self) -> SbImage"""
        return _coin.SoGLImage_getImage(self)

    def getGLDisplayList(self, state):
        r"""getGLDisplayList(SoGLImage self, SoState state) -> SoGLDisplayList"""
        return _coin.SoGLImage_getGLDisplayList(self, state)

    def hasTransparency(self):
        r"""hasTransparency(SoGLImage self) -> SbBool"""
        return _coin.SoGLImage_hasTransparency(self)

    def useAlphaTest(self):
        r"""useAlphaTest(SoGLImage self) -> SbBool"""
        return _coin.SoGLImage_useAlphaTest(self)

    def getWrapS(self):
        r"""getWrapS(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapS(self)

    def getWrapT(self):
        r"""getWrapT(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapT(self)

    def getWrapR(self):
        r"""getWrapR(SoGLImage self) -> SoGLImage::Wrap"""
        return _coin.SoGLImage_getWrapR(self)

    def getQuality(self):
        r"""getQuality(SoGLImage self) -> float"""
        return _coin.SoGLImage_getQuality(self)

    def getGLImageId(self):
        r"""getGLImageId(SoGLImage self) -> uint32_t"""
        return _coin.SoGLImage_getGLImageId(self)

    @staticmethod
    def beginFrame(state):
        r"""beginFrame(SoState state)"""
        return _coin.SoGLImage_beginFrame(state)

    @staticmethod
    def tagImage(state, image):
        r"""tagImage(SoState state, SoGLImage image)"""
        return _coin.SoGLImage_tagImage(state, image)

    @staticmethod
    def endFrame(state):
        r"""endFrame(SoState state)"""
        return _coin.SoGLImage_endFrame(state)

    @staticmethod
    def setDisplayListMaxAge(maxage):
        r"""setDisplayListMaxAge(uint32_t const maxage)"""
        return _coin.SoGLImage_setDisplayListMaxAge(maxage)

    @staticmethod
    def freeAllImages(state=None):
        r"""freeAllImages(SoState state=None)"""
        return _coin.SoGLImage_freeAllImages(state)

    def setEndFrameCallback(self, cb, closure):
        r"""setEndFrameCallback(SoGLImage self, void (*)(void *) cb, void * closure)"""
        return _coin.SoGLImage_setEndFrameCallback(self, cb, closure)

    def getNumFramesSinceUsed(self):
        r"""getNumFramesSinceUsed(SoGLImage self) -> int"""
        return _coin.SoGLImage_getNumFramesSinceUsed(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLImage_initClass()

    @staticmethod
    def setResizeCallback(f, closure):
        r"""setResizeCallback(SoGLImage::SoGLImageResizeCB * f, void * closure)"""
        return _coin.SoGLImage_setResizeCallback(f, closure)

# Register SoGLImage in _coin:
_coin.SoGLImage_swigregister(SoGLImage)
class SoGLBigImage(SoGLImage):
    r"""Proxy of C++ SoGLBigImage class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoGLBigImage self) -> SoGLBigImage"""
        _coin.SoGLBigImage_swiginit(self, _coin.new_SoGLBigImage())

    def unref(self, state=None):
        r"""unref(SoGLBigImage self, SoState state=None)"""
        return _coin.SoGLBigImage_unref(self, state)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGLBigImage_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoGLBigImage self) -> SoType"""
        return _coin.SoGLBigImage_getTypeId(self)

    def setData(self, *args):
        r"""
        setData(SoGLBigImage self, SbImage image, SoGLImage::Wrap const wraps=REPEAT, SoGLImage::Wrap const wrapt=REPEAT, 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, SoState createinstate=None)
        """
        return _coin.SoGLBigImage_setData(self, *args)

    def initSubImages(self, subimagesize):
        r"""initSubImages(SoGLBigImage self, SbVec2s subimagesize) -> int"""
        return _coin.SoGLBigImage_initSubImages(self, subimagesize)

    def handleSubImage(self, idx, start, end, tcmul):
        r"""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):
        r"""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):
        r"""exceededChangeLimit(SoGLBigImage self) -> SbBool"""
        return _coin.SoGLBigImage_exceededChangeLimit(self)

    @staticmethod
    def setChangeLimit(limit):
        r"""setChangeLimit(int const limit) -> int"""
        return _coin.SoGLBigImage_setChangeLimit(limit)

    def getGLDisplayList(self, state):
        r"""getGLDisplayList(SoGLBigImage self, SoState state) -> SoGLDisplayList"""
        return _coin.SoGLBigImage_getGLDisplayList(self, state)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGLBigImage_initClass()

# Register SoGLBigImage in _coin:
_coin.SoGLBigImage_swigregister(SoGLBigImage)
class SoGlyph(object):
    r"""Proxy of C++ SoGlyph class."""

    thisown = property(lambda x: x.this.own(), 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):
        r"""unref(SoGlyph self)"""
        return _coin.SoGlyph_unref(self)

    def getCoords(self):
        r"""getCoords(SoGlyph self) -> SbVec2f"""
        return _coin.SoGlyph_getCoords(self)

    def getFaceIndices(self):
        r"""getFaceIndices(SoGlyph self) -> int const *"""
        return _coin.SoGlyph_getFaceIndices(self)

    def getEdgeIndices(self):
        r"""getEdgeIndices(SoGlyph self) -> int const *"""
        return _coin.SoGlyph_getEdgeIndices(self)

    def getNextCWEdge(self, edgeidx):
        r"""getNextCWEdge(SoGlyph self, int const edgeidx) -> int const *"""
        return _coin.SoGlyph_getNextCWEdge(self, edgeidx)

    def getNextCCWEdge(self, edgeidx):
        r"""getNextCCWEdge(SoGlyph self, int const edgeidx) -> int const *"""
        return _coin.SoGlyph_getNextCCWEdge(self, edgeidx)

    def getWidth(self):
        r"""getWidth(SoGlyph self) -> float"""
        return _coin.SoGlyph_getWidth(self)

    def getBoundingBox(self):
        r"""getBoundingBox(SoGlyph self) -> SbBox2f"""
        return _coin.SoGlyph_getBoundingBox(self)

    @staticmethod
    def getGlyph(*args):
        r"""
        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)

    def getAdvance(self):
        r"""getAdvance(SoGlyph self) -> SbVec2s"""
        return _coin.SoGlyph_getAdvance(self)

    def getKerning(self, rightglyph):
        r"""getKerning(SoGlyph self, SoGlyph rightglyph) -> SbVec2s"""
        return _coin.SoGlyph_getKerning(self, rightglyph)

    def getBitmap(self, size, pos, antialiased):
        r"""getBitmap(SoGlyph self, SbVec2s size, SbVec2s pos, SbBool const antialiased) -> unsigned char *"""
        return _coin.SoGlyph_getBitmap(self, size, pos, antialiased)

# Register SoGlyph in _coin:
_coin.SoGlyph_swigregister(SoGlyph)
class SoProto(SoNode):
    r"""Proxy of C++ SoProto class."""

    thisown = 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):
        r"""__init__(SoProto self, SbBool const externproto=0) -> SoProto"""
        _coin.SoProto_swiginit(self, _coin.new_SoProto(externproto))

    @staticmethod
    def setFetchExternProtoCallback(cb, closure):
        r"""setFetchExternProtoCallback(SoFetchExternProtoCB * cb, void * closure)"""
        return _coin.SoProto_setFetchExternProtoCallback(cb, closure)

    def getTypeId(self):
        r"""getTypeId(SoProto self) -> SoType"""
        return _coin.SoProto_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProto_getClassTypeId()

    @staticmethod
    def findProto(name):
        r"""findProto(SbName name) -> SoProto"""
        return _coin.SoProto_findProto(name)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoProto_initClass()

    def createProtoInstance(self):
        r"""createProtoInstance(SoProto self) -> SoProtoInstance"""
        return _coin.SoProto_createProtoInstance(self)

    def addISReference(self, container, fieldname, interfacename):
        r"""addISReference(SoProto self, SoNode container, SbName fieldname, SbName interfacename)"""
        return _coin.SoProto_addISReference(self, container, fieldname, interfacename)

    def findISReference(self, container, fieldname):
        r"""findISReference(SoProto self, SoFieldContainer container, SbName fieldname) -> SbName"""
        return _coin.SoProto_findISReference(self, container, fieldname)

    def addReference(self, name, base):
        r"""addReference(SoProto self, SbName name, SoBase base)"""
        return _coin.SoProto_addReference(self, name, base)

    def removeReference(self, name):
        r"""removeReference(SoProto self, SbName name)"""
        return _coin.SoProto_removeReference(self, name)

    def findReference(self, name):
        r"""findReference(SoProto self, SbName name) -> SoBase"""
        return _coin.SoProto_findReference(self, name)

    def addRoute(self, fromnode, fromfield, tonode, tofield):
        r"""addRoute(SoProto self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"""
        return _coin.SoProto_addRoute(self, fromnode, fromfield, tonode, tofield)

    def getProtoName(self):
        r"""getProtoName(SoProto self) -> SbName"""
        return _coin.SoProto_getProtoName(self)

    def readInstance(self, input, flags):
        r"""readInstance(SoProto self, SoInput input, unsigned short flags) -> SbBool"""
        return _coin.SoProto_readInstance(self, input, flags)

    def write(self, action):
        r"""write(SoProto self, SoWriteAction action)"""
        return _coin.SoProto_write(self, action)

# Register SoProto in _coin:
_coin.SoProto_swigregister(SoProto)
class SoProtoInstance(SoNode):
    r"""Proxy of C++ SoProtoInstance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProtoInstance_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoProtoInstance self) -> SoType"""
        return _coin.SoProtoInstance_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoProtoInstance_initClass()

    def __init__(self, proto, deffielddata):
        r"""__init__(SoProtoInstance self, SoProto proto, SoFieldData deffielddata) -> SoProtoInstance"""
        _coin.SoProtoInstance_swiginit(self, _coin.new_SoProtoInstance(proto, deffielddata))

    @staticmethod
    def findProtoInstance(rootnode):
        r"""findProtoInstance(SoNode rootnode) -> SoProtoInstance"""
        return _coin.SoProtoInstance_findProtoInstance(rootnode)

    def setRootNode(self, root):
        r"""setRootNode(SoProtoInstance self, SoNode root)"""
        return _coin.SoProtoInstance_setRootNode(self, root)

    def getRootNode(self):
        r"""getRootNode(SoProtoInstance self) -> SoNode"""
        return _coin.SoProtoInstance_getRootNode(self)

    def getProtoDefinition(self):
        r"""getProtoDefinition(SoProtoInstance self) -> SoProto"""
        return _coin.SoProtoInstance_getProtoDefinition(self)

    def getProtoName(self):
        r"""getProtoName(SoProtoInstance self) -> SbName"""
        return _coin.SoProtoInstance_getProtoName(self)

    def write(self, action):
        r"""write(SoProtoInstance self, SoWriteAction action)"""
        return _coin.SoProtoInstance_write(self, action)

# Register SoProtoInstance in _coin:
_coin.SoProtoInstance_swigregister(SoProtoInstance)
class SoTranReceiver(object):
    r"""Proxy of C++ SoTranReceiver class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, root):
        r"""__init__(SoTranReceiver self, SoGroup root) -> SoTranReceiver"""
        _coin.SoTranReceiver_swiginit(self, _coin.new_SoTranReceiver(root))
    __swig_destroy__ = _coin.delete_SoTranReceiver

    def interpret(self, input):
        r"""interpret(SoTranReceiver self, SoInput input) -> SbBool"""
        return _coin.SoTranReceiver_interpret(self, input)

# Register SoTranReceiver in _coin:
_coin.SoTranReceiver_swigregister(SoTranReceiver)
class SoTranSender(object):
    r"""Proxy of C++ SoTranSender class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, output):
        r"""__init__(SoTranSender self, SoOutput output) -> SoTranSender"""
        _coin.SoTranSender_swiginit(self, _coin.new_SoTranSender(output))
    __swig_destroy__ = _coin.delete_SoTranSender

    def getOutput(self):
        r"""getOutput(SoTranSender self) -> SoOutput"""
        return _coin.SoTranSender_getOutput(self)

    def insert(self, *args):
        r"""
        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):
        r"""remove(SoTranSender self, SoNode parent, int n)"""
        return _coin.SoTranSender_remove(self, parent, n)

    def replace(self, parent, n, newnode):
        r"""replace(SoTranSender self, SoNode parent, int n, SoNode newnode)"""
        return _coin.SoTranSender_replace(self, parent, n, newnode)

    def modify(self, node):
        r"""modify(SoTranSender self, SoNode node)"""
        return _coin.SoTranSender_modify(self, node)

    def prepareToSend(self):
        r"""prepareToSend(SoTranSender self)"""
        return _coin.SoTranSender_prepareToSend(self)

# Register SoTranSender in _coin:
_coin.SoTranSender_swigregister(SoTranSender)
class SoAppearanceKit(SoBaseKit):
    r"""Proxy of C++ SoAppearanceKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAppearanceKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoAppearanceKit self) -> SoType"""
        return _coin.SoAppearanceKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoAppearanceKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoAppearanceKit self) -> SoNodekitCatalog"""
        return _coin.SoAppearanceKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoAppearanceKit self) -> SoAppearanceKit"""
        _coin.SoAppearanceKit_swiginit(self, _coin.new_SoAppearanceKit())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAppearanceKit_initClass()

# Register SoAppearanceKit in _coin:
_coin.SoAppearanceKit_swigregister(SoAppearanceKit)
class SoCameraKit(SoBaseKit):
    r"""Proxy of C++ SoCameraKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCameraKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCameraKit self) -> SoType"""
        return _coin.SoCameraKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoCameraKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoCameraKit self) -> SoNodekitCatalog"""
        return _coin.SoCameraKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoCameraKit self) -> SoCameraKit"""
        _coin.SoCameraKit_swiginit(self, _coin.new_SoCameraKit())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCameraKit_initClass()

# Register SoCameraKit in _coin:
_coin.SoCameraKit_swigregister(SoCameraKit)
class SoLightKit(SoBaseKit):
    r"""Proxy of C++ SoLightKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLightKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLightKit self) -> SoType"""
        return _coin.SoLightKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoLightKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoLightKit self) -> SoNodekitCatalog"""
        return _coin.SoLightKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoLightKit self) -> SoLightKit"""
        _coin.SoLightKit_swiginit(self, _coin.new_SoLightKit())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLightKit_initClass()

# Register SoLightKit in _coin:
_coin.SoLightKit_swigregister(SoLightKit)
class SoNodeKit(object):
    r"""Proxy of C++ SoNodeKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def init():
        r"""init()"""
        return _coin.SoNodeKit_init()

    def __init__(self):
        r"""__init__(SoNodeKit self) -> SoNodeKit"""
        _coin.SoNodeKit_swiginit(self, _coin.new_SoNodeKit())
    __swig_destroy__ = _coin.delete_SoNodeKit

# Register SoNodeKit in _coin:
_coin.SoNodeKit_swigregister(SoNodeKit)
class SoSceneKit(SoBaseKit):
    r"""Proxy of C++ SoSceneKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSceneKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSceneKit self) -> SoType"""
        return _coin.SoSceneKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSceneKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoSceneKit self) -> SoNodekitCatalog"""
        return _coin.SoSceneKit_getNodekitCatalog(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSceneKit_initClass()

    def __init__(self):
        r"""__init__(SoSceneKit self) -> SoSceneKit"""
        _coin.SoSceneKit_swiginit(self, _coin.new_SoSceneKit())

    def getCameraNumber(self):
        r"""getCameraNumber(SoSceneKit self) -> int"""
        return _coin.SoSceneKit_getCameraNumber(self)

    def setCameraNumber(self, camNum):
        r"""setCameraNumber(SoSceneKit self, int camNum)"""
        return _coin.SoSceneKit_setCameraNumber(self, camNum)

    def affectsState(self):
        r"""affectsState(SoSceneKit self) -> SbBool"""
        return _coin.SoSceneKit_affectsState(self)

# Register SoSceneKit in _coin:
_coin.SoSceneKit_swigregister(SoSceneKit)
class SoSeparatorKit(SoBaseKit):
    r"""Proxy of C++ SoSeparatorKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSeparatorKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSeparatorKit self) -> SoType"""
        return _coin.SoSeparatorKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoSeparatorKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoSeparatorKit self) -> SoNodekitCatalog"""
        return _coin.SoSeparatorKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoSeparatorKit self) -> SoSeparatorKit"""
        _coin.SoSeparatorKit_swiginit(self, _coin.new_SoSeparatorKit())
    OFF = _coin.SoSeparatorKit_OFF
    
    ON = _coin.SoSeparatorKit_ON
    
    AUTO = _coin.SoSeparatorKit_AUTO
    
    renderCaching = property(_coin.SoSeparatorKit_renderCaching_get, _coin.SoSeparatorKit_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoSeparatorKit_boundingBoxCaching_get, _coin.SoSeparatorKit_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")
    renderCulling = property(_coin.SoSeparatorKit_renderCulling_get, _coin.SoSeparatorKit_renderCulling_set, doc=r"""renderCulling : SoSFEnum""")
    pickCulling = property(_coin.SoSeparatorKit_pickCulling_get, _coin.SoSeparatorKit_pickCulling_set, doc=r"""pickCulling : SoSFEnum""")

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSeparatorKit_initClass()

# Register SoSeparatorKit in _coin:
_coin.SoSeparatorKit_swigregister(SoSeparatorKit)
class SoShapeKit(SoSeparatorKit):
    r"""Proxy of C++ SoShapeKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShapeKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShapeKit self) -> SoType"""
        return _coin.SoShapeKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoShapeKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoShapeKit self) -> SoNodekitCatalog"""
        return _coin.SoShapeKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoShapeKit self) -> SoShapeKit"""
        _coin.SoShapeKit_swiginit(self, _coin.new_SoShapeKit())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShapeKit_initClass()

# Register SoShapeKit in _coin:
_coin.SoShapeKit_swigregister(SoShapeKit)
class SoWrapperKit(SoSeparatorKit):
    r"""Proxy of C++ SoWrapperKit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWrapperKit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoWrapperKit self) -> SoType"""
        return _coin.SoWrapperKit_getTypeId(self)

    @staticmethod
    def getClassNodekitCatalog():
        r"""getClassNodekitCatalog() -> SoNodekitCatalog"""
        return _coin.SoWrapperKit_getClassNodekitCatalog()

    def getNodekitCatalog(self):
        r"""getNodekitCatalog(SoWrapperKit self) -> SoNodekitCatalog"""
        return _coin.SoWrapperKit_getNodekitCatalog(self)

    def __init__(self):
        r"""__init__(SoWrapperKit self) -> SoWrapperKit"""
        _coin.SoWrapperKit_swiginit(self, _coin.new_SoWrapperKit())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoWrapperKit_initClass()

# Register SoWrapperKit in _coin:
_coin.SoWrapperKit_swigregister(SoWrapperKit)
class SoGroup(SoNode):
    r"""Proxy of C++ SoGroup class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoGroup_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoGroup self) -> SoType"""
        return _coin.SoGroup_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoGroup_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoGroup self) -> SoGroup
        __init__(SoGroup self, int nchildren) -> SoGroup
        """
        _coin.SoGroup_swiginit(self, _coin.new_SoGroup(*args))

    def addChild(self, node):
        r"""addChild(SoGroup self, SoNode node)"""
        return _coin.SoGroup_addChild(self, node)

    def insertChild(self, child, newchildindex):
        r"""insertChild(SoGroup self, SoNode child, int newchildindex)"""
        return _coin.SoGroup_insertChild(self, child, newchildindex)

    def getChild(self, index):
        r"""getChild(SoGroup self, int index) -> SoNode"""
        return _coin.SoGroup_getChild(self, index)

    def findChild(self, node):
        r"""findChild(SoGroup self, SoNode node) -> int"""
        return _coin.SoGroup_findChild(self, node)

    def getNumChildren(self):
        r"""getNumChildren(SoGroup self) -> int"""
        return _coin.SoGroup_getNumChildren(self)

    def removeChild(self, *args):
        r"""
        removeChild(SoGroup self, int childindex)
        removeChild(SoGroup self, SoNode child)
        """
        return _coin.SoGroup_removeChild(self, *args)

    def removeAllChildren(self):
        r"""removeAllChildren(SoGroup self)"""
        return _coin.SoGroup_removeAllChildren(self)

    def replaceChild(self, *args):
        r"""
        replaceChild(SoGroup self, int index, SoNode newchild)
        replaceChild(SoGroup self, SoNode oldchild, SoNode newchild)
        """
        return _coin.SoGroup_replaceChild(self, *args)

    def doAction(self, action):
        r"""doAction(SoGroup self, SoAction action)"""
        return _coin.SoGroup_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoGroup self, SoGLRenderAction action)"""
        return _coin.SoGroup_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoGroup self, SoCallbackAction action)"""
        return _coin.SoGroup_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoGroup self, SoGetBoundingBoxAction action)"""
        return _coin.SoGroup_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoGroup self, SoGetMatrixAction action)"""
        return _coin.SoGroup_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoGroup self, SoHandleEventAction action)"""
        return _coin.SoGroup_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoGroup self, SoPickAction action)"""
        return _coin.SoGroup_pick(self, action)

    def search(self, action):
        r"""search(SoGroup self, SoSearchAction action)"""
        return _coin.SoGroup_search(self, action)

    def write(self, action):
        r"""write(SoGroup self, SoWriteAction action)"""
        return _coin.SoGroup_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoGroup self, SoGetPrimitiveCountAction action)"""
        return _coin.SoGroup_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoGroup self, SoAudioRenderAction action)"""
        return _coin.SoGroup_audioRender(self, action)

    def getChildren(self):
        r"""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 __iadd__(self, other):
        if isinstance(other, (list, tuple)):
            for other_i in other:
                self.__iadd__(other_i)
            return self
        else:
            try:
                self.addChild(other)
                return self
            except TypeError as e:
                raise TypeError(str(self.__class__) + " accepts only objects of type pivy.coin.SoNode")

    def getByName(self, name):
        for child in self:
            if name == child.getName():
                return child
        return None


    def __len__(self):
        r"""__len__(SoGroup self) -> int"""
        return _coin.SoGroup___len__(self)

    def __contains__(self, node):
        r"""__contains__(SoGroup self, SoNode node) -> int"""
        return _coin.SoGroup___contains__(self, node)

    def __getitem__(self, index):
        r"""__getitem__(SoGroup self, int index) -> SoNode"""
        return _coin.SoGroup___getitem__(self, index)

# Register SoGroup in _coin:
_coin.SoGroup_swigregister(SoGroup)
class SoSeparator(SoGroup):
    r"""Proxy of C++ SoSeparator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSeparator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSeparator self) -> SoType"""
        return _coin.SoSeparator_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSeparator_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoSeparator self) -> SoSeparator
        __init__(SoSeparator self, int const nchildren) -> SoSeparator
        """
        _coin.SoSeparator_swiginit(self, _coin.new_SoSeparator(*args))
    OFF = _coin.SoSeparator_OFF
    
    ON = _coin.SoSeparator_ON
    
    AUTO = _coin.SoSeparator_AUTO
    
    renderCaching = property(_coin.SoSeparator_renderCaching_get, _coin.SoSeparator_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoSeparator_boundingBoxCaching_get, _coin.SoSeparator_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")
    renderCulling = property(_coin.SoSeparator_renderCulling_get, _coin.SoSeparator_renderCulling_set, doc=r"""renderCulling : SoSFEnum""")
    pickCulling = property(_coin.SoSeparator_pickCulling_get, _coin.SoSeparator_pickCulling_set, doc=r"""pickCulling : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoSeparator self, SoAction action)"""
        return _coin.SoSeparator_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRender(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action):
        r"""GLRenderInPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action):
        r"""GLRenderOffPath(SoSeparator self, SoGLRenderAction action)"""
        return _coin.SoSeparator_GLRenderOffPath(self, action)

    def callback(self, action):
        r"""callback(SoSeparator self, SoCallbackAction action)"""
        return _coin.SoSeparator_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoSeparator self, SoGetBoundingBoxAction action)"""
        return _coin.SoSeparator_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoSeparator self, SoGetMatrixAction action)"""
        return _coin.SoSeparator_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoSeparator self, SoHandleEventAction action)"""
        return _coin.SoSeparator_handleEvent(self, action)

    def rayPick(self, action):
        r"""rayPick(SoSeparator self, SoRayPickAction action)"""
        return _coin.SoSeparator_rayPick(self, action)

    def search(self, action):
        r"""search(SoSeparator self, SoSearchAction action)"""
        return _coin.SoSeparator_search(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoSeparator self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSeparator_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoSeparator self, SoAudioRenderAction action)"""
        return _coin.SoSeparator_audioRender(self, action)

    def notify(self, nl):
        r"""notify(SoSeparator self, SoNotList nl)"""
        return _coin.SoSeparator_notify(self, nl)

    @staticmethod
    def setNumRenderCaches(howmany):
        r"""setNumRenderCaches(int const howmany)"""
        return _coin.SoSeparator_setNumRenderCaches(howmany)

    @staticmethod
    def getNumRenderCaches():
        r"""getNumRenderCaches() -> int"""
        return _coin.SoSeparator_getNumRenderCaches()

    def affectsState(self):
        r"""affectsState(SoSeparator self) -> SbBool"""
        return _coin.SoSeparator_affectsState(self)

# Register SoSeparator in _coin:
_coin.SoSeparator_swigregister(SoSeparator)
class SoAnnotation(SoSeparator):
    r"""Proxy of C++ SoAnnotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAnnotation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoAnnotation self) -> SoType"""
        return _coin.SoAnnotation_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAnnotation_initClass()

    def __init__(self):
        r"""__init__(SoAnnotation self) -> SoAnnotation"""
        _coin.SoAnnotation_swiginit(self, _coin.new_SoAnnotation())

    def GLRender(self, action):
        r"""GLRender(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRender(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action):
        r"""GLRenderInPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action):
        r"""GLRenderOffPath(SoAnnotation self, SoGLRenderAction action)"""
        return _coin.SoAnnotation_GLRenderOffPath(self, action)

# Register SoAnnotation in _coin:
_coin.SoAnnotation_swigregister(SoAnnotation)
class SoAntiSquish(SoTransformation):
    r"""Proxy of C++ SoAntiSquish class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAntiSquish_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoAntiSquish self) -> SoType"""
        return _coin.SoAntiSquish_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAntiSquish_initClass()

    def __init__(self):
        r"""__init__(SoAntiSquish self) -> SoAntiSquish"""
        _coin.SoAntiSquish_swiginit(self, _coin.new_SoAntiSquish())
    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 = property(_coin.SoAntiSquish_sizing_get, _coin.SoAntiSquish_sizing_set, doc=r"""sizing : SoSFEnum""")
    recalcAlways = property(_coin.SoAntiSquish_recalcAlways_get, _coin.SoAntiSquish_recalcAlways_set, doc=r"""recalcAlways : SoSFBool""")

    def recalc(self):
        r"""recalc(SoAntiSquish self)"""
        return _coin.SoAntiSquish_recalc(self)

    def doAction(self, action):
        r"""doAction(SoAntiSquish self, SoAction action)"""
        return _coin.SoAntiSquish_doAction(self, action)

# Register SoAntiSquish in _coin:
_coin.SoAntiSquish_swigregister(SoAntiSquish)
class SoArray(SoGroup):
    r"""Proxy of C++ SoArray class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoArray_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoArray self) -> SoType"""
        return _coin.SoArray_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoArray_initClass()

    def __init__(self):
        r"""__init__(SoArray self) -> SoArray"""
        _coin.SoArray_swiginit(self, _coin.new_SoArray())
    FIRST = _coin.SoArray_FIRST
    
    CENTER = _coin.SoArray_CENTER
    
    LAST = _coin.SoArray_LAST
    
    origin = property(_coin.SoArray_origin_get, _coin.SoArray_origin_set, doc=r"""origin : SoSFEnum""")
    numElements1 = property(_coin.SoArray_numElements1_get, _coin.SoArray_numElements1_set, doc=r"""numElements1 : SoSFShort""")
    numElements2 = property(_coin.SoArray_numElements2_get, _coin.SoArray_numElements2_set, doc=r"""numElements2 : SoSFShort""")
    numElements3 = property(_coin.SoArray_numElements3_get, _coin.SoArray_numElements3_set, doc=r"""numElements3 : SoSFShort""")
    separation1 = property(_coin.SoArray_separation1_get, _coin.SoArray_separation1_set, doc=r"""separation1 : SoSFVec3f""")
    separation2 = property(_coin.SoArray_separation2_get, _coin.SoArray_separation2_set, doc=r"""separation2 : SoSFVec3f""")
    separation3 = property(_coin.SoArray_separation3_get, _coin.SoArray_separation3_set, doc=r"""separation3 : SoSFVec3f""")

    def affectsState(self):
        r"""affectsState(SoArray self) -> SbBool"""
        return _coin.SoArray_affectsState(self)

    def doAction(self, action):
        r"""doAction(SoArray self, SoAction action)"""
        return _coin.SoArray_doAction(self, action)

    def callback(self, action):
        r"""callback(SoArray self, SoCallbackAction action)"""
        return _coin.SoArray_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoArray self, SoGLRenderAction action)"""
        return _coin.SoArray_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoArray self, SoPickAction action)"""
        return _coin.SoArray_pick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoArray self, SoGetBoundingBoxAction action)"""
        return _coin.SoArray_getBoundingBox(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoArray self, SoHandleEventAction action)"""
        return _coin.SoArray_handleEvent(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoArray self, SoGetMatrixAction action)"""
        return _coin.SoArray_getMatrix(self, action)

    def search(self, action):
        r"""search(SoArray self, SoSearchAction action)"""
        return _coin.SoArray_search(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoArray self, SoGetPrimitiveCountAction action)"""
        return _coin.SoArray_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoArray self, SoAudioRenderAction action)"""
        return _coin.SoArray_audioRender(self, action)

# Register SoArray in _coin:
_coin.SoArray_swigregister(SoArray)
class SoAsciiText(SoShape):
    r"""Proxy of C++ SoAsciiText class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoAsciiText_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoAsciiText self) -> SoType"""
        return _coin.SoAsciiText_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoAsciiText_initClass()

    def __init__(self):
        r"""__init__(SoAsciiText self) -> SoAsciiText"""
        _coin.SoAsciiText_swiginit(self, _coin.new_SoAsciiText())
    LEFT = _coin.SoAsciiText_LEFT
    
    RIGHT = _coin.SoAsciiText_RIGHT
    
    CENTER = _coin.SoAsciiText_CENTER
    
    string = property(_coin.SoAsciiText_string_get, _coin.SoAsciiText_string_set, doc=r"""string : SoMFString""")
    spacing = property(_coin.SoAsciiText_spacing_get, _coin.SoAsciiText_spacing_set, doc=r"""spacing : SoSFFloat""")
    justification = property(_coin.SoAsciiText_justification_get, _coin.SoAsciiText_justification_set, doc=r"""justification : SoSFEnum""")
    width = property(_coin.SoAsciiText_width_get, _coin.SoAsciiText_width_set, doc=r"""width : SoMFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoAsciiText self, SoGLRenderAction action)"""
        return _coin.SoAsciiText_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoAsciiText self, SoGetPrimitiveCountAction action)"""
        return _coin.SoAsciiText_getPrimitiveCount(self, action)

# Register SoAsciiText in _coin:
_coin.SoAsciiText_swigregister(SoAsciiText)
class SoBaseColor(SoNode):
    r"""Proxy of C++ SoBaseColor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBaseColor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoBaseColor self) -> SoType"""
        return _coin.SoBaseColor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBaseColor_initClass()

    def __init__(self):
        r"""__init__(SoBaseColor self) -> SoBaseColor"""
        _coin.SoBaseColor_swiginit(self, _coin.new_SoBaseColor())
    rgb = property(_coin.SoBaseColor_rgb_get, _coin.SoBaseColor_rgb_set, doc=r"""rgb : SoMFColor""")

    def doAction(self, action):
        r"""doAction(SoBaseColor self, SoAction action)"""
        return _coin.SoBaseColor_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoBaseColor self, SoGLRenderAction action)"""
        return _coin.SoBaseColor_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoBaseColor self, SoCallbackAction action)"""
        return _coin.SoBaseColor_callback(self, action)

# Register SoBaseColor in _coin:
_coin.SoBaseColor_swigregister(SoBaseColor)
SO_SWITCH_NONE = _coin.SO_SWITCH_NONE

SO_SWITCH_INHERIT = _coin.SO_SWITCH_INHERIT

SO_SWITCH_ALL = _coin.SO_SWITCH_ALL

class SoSwitch(SoGroup):
    r"""Proxy of C++ SoSwitch class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSwitch_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSwitch self) -> SoType"""
        return _coin.SoSwitch_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSwitch_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoSwitch self) -> SoSwitch
        __init__(SoSwitch self, int numchildren) -> SoSwitch
        """
        _coin.SoSwitch_swiginit(self, _coin.new_SoSwitch(*args))
    whichChild = property(_coin.SoSwitch_whichChild_get, _coin.SoSwitch_whichChild_set, doc=r"""whichChild : SoSFInt32""")

    def affectsState(self):
        r"""affectsState(SoSwitch self) -> SbBool"""
        return _coin.SoSwitch_affectsState(self)

    def doAction(self, action):
        r"""doAction(SoSwitch self, SoAction action)"""
        return _coin.SoSwitch_doAction(self, action)

    def callback(self, action):
        r"""callback(SoSwitch self, SoCallbackAction action)"""
        return _coin.SoSwitch_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoSwitch self, SoGLRenderAction action)"""
        return _coin.SoSwitch_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoSwitch self, SoPickAction action)"""
        return _coin.SoSwitch_pick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoSwitch_getBoundingBox(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoSwitch self, SoHandleEventAction action)"""
        return _coin.SoSwitch_handleEvent(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoSwitch self, SoGetMatrixAction action)"""
        return _coin.SoSwitch_getMatrix(self, action)

    def search(self, action):
        r"""search(SoSwitch self, SoSearchAction action)"""
        return _coin.SoSwitch_search(self, action)

    def write(self, action):
        r"""write(SoSwitch self, SoWriteAction action)"""
        return _coin.SoSwitch_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoSwitch self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSwitch_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoSwitch self, SoAudioRenderAction action)"""
        return _coin.SoSwitch_audioRender(self, action)

    def notify(self, nl):
        r"""notify(SoSwitch self, SoNotList nl)"""
        return _coin.SoSwitch_notify(self, nl)

# Register SoSwitch in _coin:
_coin.SoSwitch_swigregister(SoSwitch)
class SoBlinker(SoSwitch):
    r"""Proxy of C++ SoBlinker class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBlinker_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoBlinker self) -> SoType"""
        return _coin.SoBlinker_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBlinker_initClass()

    def __init__(self):
        r"""__init__(SoBlinker self) -> SoBlinker"""
        _coin.SoBlinker_swiginit(self, _coin.new_SoBlinker())
    speed = property(_coin.SoBlinker_speed_get, _coin.SoBlinker_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoBlinker_on_get, _coin.SoBlinker_on_set, doc=r"""on : SoSFBool""")

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoBlinker self, SoGetBoundingBoxAction action)"""
        return _coin.SoBlinker_getBoundingBox(self, action)

    def write(self, action):
        r"""write(SoBlinker self, SoWriteAction action)"""
        return _coin.SoBlinker_write(self, action)

# Register SoBlinker in _coin:
_coin.SoBlinker_swigregister(SoBlinker)
class SoBumpMapCoordinate(SoNode):
    r"""Proxy of C++ SoBumpMapCoordinate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapCoordinate_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoBumpMapCoordinate self) -> SoType"""
        return _coin.SoBumpMapCoordinate_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBumpMapCoordinate_initClass()

    def __init__(self):
        r"""__init__(SoBumpMapCoordinate self) -> SoBumpMapCoordinate"""
        _coin.SoBumpMapCoordinate_swiginit(self, _coin.new_SoBumpMapCoordinate())
    point = property(_coin.SoBumpMapCoordinate_point_get, _coin.SoBumpMapCoordinate_point_set, doc=r"""point : SoMFVec2f""")

    def doAction(self, action):
        r"""doAction(SoBumpMapCoordinate self, SoAction action)"""
        return _coin.SoBumpMapCoordinate_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoBumpMapCoordinate self, SoGLRenderAction action)"""
        return _coin.SoBumpMapCoordinate_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoBumpMapCoordinate self, SoCallbackAction action)"""
        return _coin.SoBumpMapCoordinate_callback(self, action)

    def pick(self, action):
        r"""pick(SoBumpMapCoordinate self, SoPickAction action)"""
        return _coin.SoBumpMapCoordinate_pick(self, action)

# Register SoBumpMapCoordinate in _coin:
_coin.SoBumpMapCoordinate_swigregister(SoBumpMapCoordinate)
class SoBumpMap(SoNode):
    r"""Proxy of C++ SoBumpMap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMap_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoBumpMap self) -> SoType"""
        return _coin.SoBumpMap_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBumpMap_initClass()

    def __init__(self):
        r"""__init__(SoBumpMap self) -> SoBumpMap"""
        _coin.SoBumpMap_swiginit(self, _coin.new_SoBumpMap())
    REPEAT = _coin.SoBumpMap_REPEAT
    
    CLAMP = _coin.SoBumpMap_CLAMP
    
    filename = property(_coin.SoBumpMap_filename_get, _coin.SoBumpMap_filename_set, doc=r"""filename : SoSFString""")
    image = property(_coin.SoBumpMap_image_get, _coin.SoBumpMap_image_set, doc=r"""image : SoSFImage""")
    wrapS = property(_coin.SoBumpMap_wrapS_get, _coin.SoBumpMap_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoBumpMap_wrapT_get, _coin.SoBumpMap_wrapT_set, doc=r"""wrapT : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoBumpMap self, SoAction action)"""
        return _coin.SoBumpMap_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoBumpMap self, SoGLRenderAction action)"""
        return _coin.SoBumpMap_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoBumpMap self, SoCallbackAction action)"""
        return _coin.SoBumpMap_callback(self, action)

    def rayPick(self, action):
        r"""rayPick(SoBumpMap self, SoRayPickAction action)"""
        return _coin.SoBumpMap_rayPick(self, action)

# Register SoBumpMap in _coin:
_coin.SoBumpMap_swigregister(SoBumpMap)
class SoBumpMapTransform(SoNode):
    r"""Proxy of C++ SoBumpMapTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoBumpMapTransform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoBumpMapTransform self) -> SoType"""
        return _coin.SoBumpMapTransform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoBumpMapTransform_initClass()

    def __init__(self):
        r"""__init__(SoBumpMapTransform self) -> SoBumpMapTransform"""
        _coin.SoBumpMapTransform_swiginit(self, _coin.new_SoBumpMapTransform())
    translation = property(_coin.SoBumpMapTransform_translation_get, _coin.SoBumpMapTransform_translation_set, doc=r"""translation : SoSFVec2f""")
    rotation = property(_coin.SoBumpMapTransform_rotation_get, _coin.SoBumpMapTransform_rotation_set, doc=r"""rotation : SoSFFloat""")
    scaleFactor = property(_coin.SoBumpMapTransform_scaleFactor_get, _coin.SoBumpMapTransform_scaleFactor_set, doc=r"""scaleFactor : SoSFVec2f""")
    center = property(_coin.SoBumpMapTransform_center_get, _coin.SoBumpMapTransform_center_set, doc=r"""center : SoSFVec2f""")

    def doAction(self, action):
        r"""doAction(SoBumpMapTransform self, SoAction action)"""
        return _coin.SoBumpMapTransform_doAction(self, action)

    def callback(self, action):
        r"""callback(SoBumpMapTransform self, SoCallbackAction action)"""
        return _coin.SoBumpMapTransform_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoBumpMapTransform self, SoGLRenderAction action)"""
        return _coin.SoBumpMapTransform_GLRender(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoBumpMapTransform self, SoGetMatrixAction action)"""
        return _coin.SoBumpMapTransform_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoBumpMapTransform self, SoPickAction action)"""
        return _coin.SoBumpMapTransform_pick(self, action)

# Register SoBumpMapTransform in _coin:
_coin.SoBumpMapTransform_swigregister(SoBumpMapTransform)
class SoCallback(SoNode):
    r"""Proxy of C++ SoCallback class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCallback_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCallback self) -> SoType"""
        return _coin.SoCallback_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCallback_initClass()

    def __init__(self):
        r"""__init__(SoCallback self) -> SoCallback"""
        _coin.SoCallback_swiginit(self, _coin.new_SoCallback())

    def doAction(self, action):
        r"""doAction(SoCallback self, SoAction action)"""
        return _coin.SoCallback_doAction(self, action)

    def callback(self, action):
        r"""callback(SoCallback self, SoCallbackAction action)"""
        return _coin.SoCallback_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoCallback self, SoGLRenderAction action)"""
        return _coin.SoCallback_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoCallback self, SoGetBoundingBoxAction action)"""
        return _coin.SoCallback_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoCallback self, SoGetMatrixAction action)"""
        return _coin.SoCallback_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoCallback self, SoHandleEventAction action)"""
        return _coin.SoCallback_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoCallback self, SoPickAction action)"""
        return _coin.SoCallback_pick(self, action)

    def search(self, action):
        r"""search(SoCallback self, SoSearchAction action)"""
        return _coin.SoCallback_search(self, action)

    def write(self, action):
        r"""write(SoCallback self, SoWriteAction action)"""
        return _coin.SoCallback_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoCallback self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCallback_getPrimitiveCount(self, action)

    def setCallback(self, *args):
        r"""
        setCallback(SoCallback self, SoCallbackCB * function, void * userdata=None)
        setCallback(SoCallback self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoCallback_setCallback(self, *args)

# Register SoCallback in _coin:
_coin.SoCallback_swigregister(SoCallback)
SO_ASPECT_SQUARE = _coin.SO_ASPECT_SQUARE

SO_ASPECT_VIDEO = _coin.SO_ASPECT_VIDEO

SO_ASPECT_35mm_ACADEMY = _coin.SO_ASPECT_35mm_ACADEMY

SO_ASPECT_16mm = _coin.SO_ASPECT_16mm

SO_ASPECT_35mm_FULL = _coin.SO_ASPECT_35mm_FULL

SO_ASPECT_70mm = _coin.SO_ASPECT_70mm

SO_ASPECT_CINEMASCOPE = _coin.SO_ASPECT_CINEMASCOPE

SO_ASPECT_HDTV = _coin.SO_ASPECT_HDTV

SO_ASPECT_PANAVISION = _coin.SO_ASPECT_PANAVISION

SO_ASPECT_35mm = _coin.SO_ASPECT_35mm

SO_ASPECT_VISTAVISION = _coin.SO_ASPECT_VISTAVISION

class SoCamera(SoNode):
    r"""Proxy of C++ SoCamera class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCamera_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCamera self) -> SoType"""
        return _coin.SoCamera_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCamera_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 = property(_coin.SoCamera_viewportMapping_get, _coin.SoCamera_viewportMapping_set, doc=r"""viewportMapping : SoSFEnum""")
    position = property(_coin.SoCamera_position_get, _coin.SoCamera_position_set, doc=r"""position : SoSFVec3f""")
    orientation = property(_coin.SoCamera_orientation_get, _coin.SoCamera_orientation_set, doc=r"""orientation : SoSFRotation""")
    aspectRatio = property(_coin.SoCamera_aspectRatio_get, _coin.SoCamera_aspectRatio_set, doc=r"""aspectRatio : SoSFFloat""")
    nearDistance = property(_coin.SoCamera_nearDistance_get, _coin.SoCamera_nearDistance_set, doc=r"""nearDistance : SoSFFloat""")
    farDistance = property(_coin.SoCamera_farDistance_get, _coin.SoCamera_farDistance_set, doc=r"""farDistance : SoSFFloat""")
    focalDistance = property(_coin.SoCamera_focalDistance_get, _coin.SoCamera_focalDistance_set, doc=r"""focalDistance : SoSFFloat""")

    def pointAt(self, *args):
        r"""
        pointAt(SoCamera self, SbVec3f targetpoint)
        pointAt(SoCamera self, SbVec3f targetpoint, SbVec3f upvector)
        """
        return _coin.SoCamera_pointAt(self, *args)

    def scaleHeight(self, scalefactor):
        r"""scaleHeight(SoCamera self, float scalefactor)"""
        return _coin.SoCamera_scaleHeight(self, scalefactor)

    def getViewVolume(self, useaspectratio=0.0):
        r"""getViewVolume(SoCamera self, float useaspectratio=0.0) -> SbViewVolume"""
        return _coin.SoCamera_getViewVolume(self, useaspectratio)

    def viewAll(self, *args):
        r"""
        viewAll(SoCamera self, SoNode sceneroot, SbViewportRegion vpregion, float const slack=1.0)
        viewAll(SoCamera self, SoPath path, SbViewportRegion vpregion, float const slack=1.0)
        """
        return _coin.SoCamera_viewAll(self, *args)

    def getViewportBounds(self, region):
        r"""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):
        r"""setStereoMode(SoCamera self, SoCamera::StereoMode mode)"""
        return _coin.SoCamera_setStereoMode(self, mode)

    def getStereoMode(self):
        r"""getStereoMode(SoCamera self) -> SoCamera::StereoMode"""
        return _coin.SoCamera_getStereoMode(self)

    def setStereoAdjustment(self, adjustment):
        r"""setStereoAdjustment(SoCamera self, float adjustment)"""
        return _coin.SoCamera_setStereoAdjustment(self, adjustment)

    def getStereoAdjustment(self):
        r"""getStereoAdjustment(SoCamera self) -> float"""
        return _coin.SoCamera_getStereoAdjustment(self)

    def setBalanceAdjustment(self, adjustment):
        r"""setBalanceAdjustment(SoCamera self, float adjustment)"""
        return _coin.SoCamera_setBalanceAdjustment(self, adjustment)

    def getBalanceAdjustment(self):
        r"""getBalanceAdjustment(SoCamera self) -> float"""
        return _coin.SoCamera_getBalanceAdjustment(self)

    def doAction(self, action):
        r"""doAction(SoCamera self, SoAction action)"""
        return _coin.SoCamera_doAction(self, action)

    def callback(self, action):
        r"""callback(SoCamera self, SoCallbackAction action)"""
        return _coin.SoCamera_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoCamera self, SoGLRenderAction action)"""
        return _coin.SoCamera_GLRender(self, action)

    def audioRender(self, action):
        r"""audioRender(SoCamera self, SoAudioRenderAction action)"""
        return _coin.SoCamera_audioRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoCamera self, SoGetBoundingBoxAction action)"""
        return _coin.SoCamera_getBoundingBox(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoCamera self, SoHandleEventAction action)"""
        return _coin.SoCamera_handleEvent(self, action)

    def rayPick(self, action):
        r"""rayPick(SoCamera self, SoRayPickAction action)"""
        return _coin.SoCamera_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoCamera self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCamera_getPrimitiveCount(self, action)

# Register SoCamera in _coin:
_coin.SoCamera_swigregister(SoCamera)
class SoColorIndex(SoNode):
    r"""Proxy of C++ SoColorIndex class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoColorIndex_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoColorIndex self) -> SoType"""
        return _coin.SoColorIndex_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoColorIndex_initClass()

    def __init__(self):
        r"""__init__(SoColorIndex self) -> SoColorIndex"""
        _coin.SoColorIndex_swiginit(self, _coin.new_SoColorIndex())
    index = property(_coin.SoColorIndex_index_get, _coin.SoColorIndex_index_set, doc=r"""index : SoMFInt32""")

    def GLRender(self, action):
        r"""GLRender(SoColorIndex self, SoGLRenderAction action)"""
        return _coin.SoColorIndex_GLRender(self, action)

# Register SoColorIndex in _coin:
_coin.SoColorIndex_swigregister(SoColorIndex)
class SoCone(SoShape):
    r"""Proxy of C++ SoCone class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCone_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCone self) -> SoType"""
        return _coin.SoCone_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCone_initClass()

    def __init__(self):
        r"""__init__(SoCone self) -> SoCone"""
        _coin.SoCone_swiginit(self, _coin.new_SoCone())
    SIDES = _coin.SoCone_SIDES
    
    BOTTOM = _coin.SoCone_BOTTOM
    
    ALL = _coin.SoCone_ALL
    
    parts = property(_coin.SoCone_parts_get, _coin.SoCone_parts_set, doc=r"""parts : SoSFBitMask""")
    bottomRadius = property(_coin.SoCone_bottomRadius_get, _coin.SoCone_bottomRadius_set, doc=r"""bottomRadius : SoSFFloat""")
    height = property(_coin.SoCone_height_get, _coin.SoCone_height_set, doc=r"""height : SoSFFloat""")

    def addPart(self, part):
        r"""addPart(SoCone self, SoCone::Part part)"""
        return _coin.SoCone_addPart(self, part)

    def removePart(self, part):
        r"""removePart(SoCone self, SoCone::Part part)"""
        return _coin.SoCone_removePart(self, part)

    def hasPart(self, part):
        r"""hasPart(SoCone self, SoCone::Part part) -> SbBool"""
        return _coin.SoCone_hasPart(self, part)

    def GLRender(self, action):
        r"""GLRender(SoCone self, SoGLRenderAction action)"""
        return _coin.SoCone_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoCone self, SoRayPickAction action)"""
        return _coin.SoCone_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoCone self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCone_getPrimitiveCount(self, action)

# Register SoCone in _coin:
_coin.SoCone_swigregister(SoCone)
class SoCoordinate3(SoNode):
    r"""Proxy of C++ SoCoordinate3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCoordinate3_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCoordinate3 self) -> SoType"""
        return _coin.SoCoordinate3_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCoordinate3_initClass()

    def __init__(self):
        r"""__init__(SoCoordinate3 self) -> SoCoordinate3"""
        _coin.SoCoordinate3_swiginit(self, _coin.new_SoCoordinate3())
    point = property(_coin.SoCoordinate3_point_get, _coin.SoCoordinate3_point_set, doc=r"""point : SoMFVec3f""")

    def doAction(self, action):
        r"""doAction(SoCoordinate3 self, SoAction action)"""
        return _coin.SoCoordinate3_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoCoordinate3_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoCoordinate3_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoCoordinate3 self, SoGetBoundingBoxAction action)"""
        return _coin.SoCoordinate3_getBoundingBox(self, action)

    def pick(self, action):
        r"""pick(SoCoordinate3 self, SoPickAction action)"""
        return _coin.SoCoordinate3_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoCoordinate3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCoordinate3_getPrimitiveCount(self, action)

# Register SoCoordinate3 in _coin:
_coin.SoCoordinate3_swigregister(SoCoordinate3)
class SoCoordinate4(SoNode):
    r"""Proxy of C++ SoCoordinate4 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCoordinate4_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCoordinate4 self) -> SoType"""
        return _coin.SoCoordinate4_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCoordinate4_initClass()

    def __init__(self):
        r"""__init__(SoCoordinate4 self) -> SoCoordinate4"""
        _coin.SoCoordinate4_swiginit(self, _coin.new_SoCoordinate4())
    point = property(_coin.SoCoordinate4_point_get, _coin.SoCoordinate4_point_set, doc=r"""point : SoMFVec4f""")

    def doAction(self, action):
        r"""doAction(SoCoordinate4 self, SoAction action)"""
        return _coin.SoCoordinate4_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoCoordinate4 self, SoGLRenderAction action)"""
        return _coin.SoCoordinate4_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoCoordinate4 self, SoGetBoundingBoxAction action)"""
        return _coin.SoCoordinate4_getBoundingBox(self, action)

    def callback(self, action):
        r"""callback(SoCoordinate4 self, SoCallbackAction action)"""
        return _coin.SoCoordinate4_callback(self, action)

    def pick(self, action):
        r"""pick(SoCoordinate4 self, SoPickAction action)"""
        return _coin.SoCoordinate4_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoCoordinate4 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCoordinate4_getPrimitiveCount(self, action)

# Register SoCoordinate4 in _coin:
_coin.SoCoordinate4_swigregister(SoCoordinate4)
class SoCube(SoShape):
    r"""Proxy of C++ SoCube class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCube_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCube self) -> SoType"""
        return _coin.SoCube_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCube_initClass()

    def __init__(self):
        r"""__init__(SoCube self) -> SoCube"""
        _coin.SoCube_swiginit(self, _coin.new_SoCube())
    width = property(_coin.SoCube_width_get, _coin.SoCube_width_set, doc=r"""width : SoSFFloat""")
    height = property(_coin.SoCube_height_get, _coin.SoCube_height_set, doc=r"""height : SoSFFloat""")
    depth = property(_coin.SoCube_depth_get, _coin.SoCube_depth_set, doc=r"""depth : SoSFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoCube self, SoGLRenderAction action)"""
        return _coin.SoCube_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoCube self, SoRayPickAction action)"""
        return _coin.SoCube_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoCube self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCube_getPrimitiveCount(self, action)

# Register SoCube in _coin:
_coin.SoCube_swigregister(SoCube)
class SoCylinder(SoShape):
    r"""Proxy of C++ SoCylinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCylinder_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCylinder self) -> SoType"""
        return _coin.SoCylinder_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCylinder_initClass()

    def __init__(self):
        r"""__init__(SoCylinder self) -> SoCylinder"""
        _coin.SoCylinder_swiginit(self, _coin.new_SoCylinder())
    SIDES = _coin.SoCylinder_SIDES
    
    TOP = _coin.SoCylinder_TOP
    
    BOTTOM = _coin.SoCylinder_BOTTOM
    
    ALL = _coin.SoCylinder_ALL
    
    radius = property(_coin.SoCylinder_radius_get, _coin.SoCylinder_radius_set, doc=r"""radius : SoSFFloat""")
    height = property(_coin.SoCylinder_height_get, _coin.SoCylinder_height_set, doc=r"""height : SoSFFloat""")
    parts = property(_coin.SoCylinder_parts_get, _coin.SoCylinder_parts_set, doc=r"""parts : SoSFBitMask""")

    def addPart(self, part):
        r"""addPart(SoCylinder self, SoCylinder::Part part)"""
        return _coin.SoCylinder_addPart(self, part)

    def removePart(self, part):
        r"""removePart(SoCylinder self, SoCylinder::Part part)"""
        return _coin.SoCylinder_removePart(self, part)

    def hasPart(self, part):
        r"""hasPart(SoCylinder self, SoCylinder::Part part) -> SbBool"""
        return _coin.SoCylinder_hasPart(self, part)

    def rayPick(self, action):
        r"""rayPick(SoCylinder self, SoRayPickAction action)"""
        return _coin.SoCylinder_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoCylinder self, SoGetPrimitiveCountAction action)"""
        return _coin.SoCylinder_getPrimitiveCount(self, action)

    def GLRender(self, action):
        r"""GLRender(SoCylinder self, SoGLRenderAction action)"""
        return _coin.SoCylinder_GLRender(self, action)

# Register SoCylinder in _coin:
_coin.SoCylinder_swigregister(SoCylinder)
class SoEnvironment(SoNode):
    r"""Proxy of C++ SoEnvironment class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEnvironment_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoEnvironment self) -> SoType"""
        return _coin.SoEnvironment_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoEnvironment_initClass()

    def __init__(self):
        r"""__init__(SoEnvironment self) -> SoEnvironment"""
        _coin.SoEnvironment_swiginit(self, _coin.new_SoEnvironment())
    NONE = _coin.SoEnvironment_NONE
    
    HAZE = _coin.SoEnvironment_HAZE
    
    FOG = _coin.SoEnvironment_FOG
    
    SMOKE = _coin.SoEnvironment_SMOKE
    

    def GLRender(self, action):
        r"""GLRender(SoEnvironment self, SoGLRenderAction action)"""
        return _coin.SoEnvironment_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoEnvironment self, SoCallbackAction action)"""
        return _coin.SoEnvironment_callback(self, action)
    ambientIntensity = property(_coin.SoEnvironment_ambientIntensity_get, _coin.SoEnvironment_ambientIntensity_set, doc=r"""ambientIntensity : SoSFFloat""")
    ambientColor = property(_coin.SoEnvironment_ambientColor_get, _coin.SoEnvironment_ambientColor_set, doc=r"""ambientColor : SoSFColor""")
    attenuation = property(_coin.SoEnvironment_attenuation_get, _coin.SoEnvironment_attenuation_set, doc=r"""attenuation : SoSFVec3f""")
    fogType = property(_coin.SoEnvironment_fogType_get, _coin.SoEnvironment_fogType_set, doc=r"""fogType : SoSFEnum""")
    fogColor = property(_coin.SoEnvironment_fogColor_get, _coin.SoEnvironment_fogColor_set, doc=r"""fogColor : SoSFColor""")
    fogVisibility = property(_coin.SoEnvironment_fogVisibility_get, _coin.SoEnvironment_fogVisibility_set, doc=r"""fogVisibility : SoSFFloat""")

# Register SoEnvironment in _coin:
_coin.SoEnvironment_swigregister(SoEnvironment)
class SoEventCallback(SoNode):
    r"""Proxy of C++ SoEventCallback class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoEventCallback_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoEventCallback self) -> SoType"""
        return _coin.SoEventCallback_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoEventCallback_initClass()

    def __init__(self):
        r"""__init__(SoEventCallback self) -> SoEventCallback"""
        _coin.SoEventCallback_swiginit(self, _coin.new_SoEventCallback())

    def setPath(self, path):
        r"""setPath(SoEventCallback self, SoPath path)"""
        return _coin.SoEventCallback_setPath(self, path)

    def getPath(self):
        r"""getPath(SoEventCallback self) -> SoPath"""
        return _coin.SoEventCallback_getPath(self)

    def getAction(self):
        r"""getAction(SoEventCallback self) -> SoHandleEventAction"""
        return _coin.SoEventCallback_getAction(self)

    def getEvent(self):
        r"""getEvent(SoEventCallback self) -> SoEvent"""
        return _coin.SoEventCallback_getEvent(self)

    def getPickedPoint(self):
        r"""getPickedPoint(SoEventCallback self) -> SoPickedPoint"""
        return _coin.SoEventCallback_getPickedPoint(self)

    def setHandled(self):
        r"""setHandled(SoEventCallback self)"""
        return _coin.SoEventCallback_setHandled(self)

    def isHandled(self):
        r"""isHandled(SoEventCallback self) -> SbBool"""
        return _coin.SoEventCallback_isHandled(self)

    def grabEvents(self):
        r"""grabEvents(SoEventCallback self)"""
        return _coin.SoEventCallback_grabEvents(self)

    def releaseEvents(self):
        r"""releaseEvents(SoEventCallback self)"""
        return _coin.SoEventCallback_releaseEvents(self)

    def addEventCallback(self, *args):
        r"""
        addEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f, void * userdata=None)
        addEventCallback(SoEventCallback self, SoType eventtype, PyObject * pyfunc, PyObject * userdata=None) -> PyObject
        """
        return _coin.SoEventCallback_addEventCallback(self, *args)

    def removeEventCallback(self, *args):
        r"""
        removeEventCallback(SoEventCallback self, SoType eventtype, SoEventCallbackCB * f, void * userdata=None)
        removeEventCallback(SoEventCallback self, SoType eventtype, PyObject * tuple)
        """
        return _coin.SoEventCallback_removeEventCallback(self, *args)

# Register SoEventCallback in _coin:
_coin.SoEventCallback_swigregister(SoEventCallback)
class SoSelection(SoSeparator):
    r"""Proxy of C++ SoSelection class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSelection_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSelection self) -> SoType"""
        return _coin.SoSelection_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSelection_initClass()
    SINGLE = _coin.SoSelection_SINGLE
    
    TOGGLE = _coin.SoSelection_TOGGLE
    
    SHIFT = _coin.SoSelection_SHIFT
    
    policy = property(_coin.SoSelection_policy_get, _coin.SoSelection_policy_set, doc=r"""policy : SoSFEnum""")

    def __init__(self, *args):
        r"""
        __init__(SoSelection self) -> SoSelection
        __init__(SoSelection self, int const nChildren) -> SoSelection
        """
        _coin.SoSelection_swiginit(self, _coin.new_SoSelection(*args))

    def select(self, *args):
        r"""
        select(SoSelection self, SoPath path)
        select(SoSelection self, SoNode node)
        """
        return _coin.SoSelection_select(self, *args)

    def deselect(self, *args):
        r"""
        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):
        r"""
        toggle(SoSelection self, SoPath path)
        toggle(SoSelection self, SoNode node)
        """
        return _coin.SoSelection_toggle(self, *args)

    def isSelected(self, *args):
        r"""
        isSelected(SoSelection self, SoPath path) -> SbBool
        isSelected(SoSelection self, SoNode node) -> SbBool
        """
        return _coin.SoSelection_isSelected(self, *args)

    def deselectAll(self):
        r"""deselectAll(SoSelection self)"""
        return _coin.SoSelection_deselectAll(self)

    def getNumSelected(self):
        r"""getNumSelected(SoSelection self) -> int"""
        return _coin.SoSelection_getNumSelected(self)

    def getList(self):
        r"""getList(SoSelection self) -> SoPathList"""
        return _coin.SoSelection_getList(self)

    def getPath(self, index):
        r"""getPath(SoSelection self, int const index) -> SoPath"""
        return _coin.SoSelection_getPath(self, index)

    def setPickMatching(self, pickMatching):
        r"""setPickMatching(SoSelection self, SbBool const pickMatching)"""
        return _coin.SoSelection_setPickMatching(self, pickMatching)

    def isPickMatching(self):
        r"""isPickMatching(SoSelection self) -> SbBool"""
        return _coin.SoSelection_isPickMatching(self)

    def getPickMatching(self):
        r"""getPickMatching(SoSelection self) -> SbBool"""
        return _coin.SoSelection_getPickMatching(self)

    def addSelectionCallback(self, *args):
        r"""
        addSelectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        addSelectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addSelectionCallback(self, *args)

    def removeSelectionCallback(self, *args):
        r"""
        removeSelectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        removeSelectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeSelectionCallback(self, *args)

    def addDeselectionCallback(self, *args):
        r"""
        addDeselectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        addDeselectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addDeselectionCallback(self, *args)

    def removeDeselectionCallback(self, *args):
        r"""
        removeDeselectionCallback(SoSelection self, SoSelectionPathCB * f, void * userData=None)
        removeDeselectionCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeDeselectionCallback(self, *args)

    def addStartCallback(self, *args):
        r"""
        addStartCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addStartCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addStartCallback(self, *args)

    def removeStartCallback(self, *args):
        r"""
        removeStartCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeStartCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeStartCallback(self, *args)

    def addFinishCallback(self, *args):
        r"""
        addFinishCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addFinishCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addFinishCallback(self, *args)

    def removeFinishCallback(self, *args):
        r"""
        removeFinishCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeFinishCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeFinishCallback(self, *args)

    def setPickFilterCallback(self, *args):
        r"""
        setPickFilterCallback(SoSelection self, SoSelectionPickCB * f, void * userData=None, SbBool const callOnlyIfSelectable=1)
        setPickFilterCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None, int callOnlyIfSelectable=1)
        """
        return _coin.SoSelection_setPickFilterCallback(self, *args)

    def addChangeCallback(self, *args):
        r"""
        addChangeCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        addChangeCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_addChangeCallback(self, *args)

    def removeChangeCallback(self, *args):
        r"""
        removeChangeCallback(SoSelection self, SoSelectionClassCB * f, void * userData=None)
        removeChangeCallback(SoSelection self, PyObject * pyfunc, PyObject * userdata=None)
        """
        return _coin.SoSelection_removeChangeCallback(self, *args)

# Register SoSelection in _coin:
_coin.SoSelection_swigregister(SoSelection)
class SoExtSelection(SoSelection):
    r"""Proxy of C++ SoExtSelection class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoExtSelection_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoExtSelection self) -> SoType"""
        return _coin.SoExtSelection_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoExtSelection_initClass()

    def __init__(self):
        r"""__init__(SoExtSelection self) -> SoExtSelection"""
        _coin.SoExtSelection_swiginit(self, _coin.new_SoExtSelection())
    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 = property(_coin.SoExtSelection_lassoType_get, _coin.SoExtSelection_lassoType_set, doc=r"""lassoType : SoSFEnum""")
    lassoPolicy = property(_coin.SoExtSelection_lassoPolicy_get, _coin.SoExtSelection_lassoPolicy_set, doc=r"""lassoPolicy : SoSFEnum""")
    lassoMode = property(_coin.SoExtSelection_lassoMode_get, _coin.SoExtSelection_lassoMode_set, doc=r"""lassoMode : SoSFEnum""")

    def useOverlay(self, overlay=1):
        r"""useOverlay(SoExtSelection self, SbBool overlay=1)"""
        return _coin.SoExtSelection_useOverlay(self, overlay)

    def isUsingOverlay(self):
        r"""isUsingOverlay(SoExtSelection self) -> SbBool"""
        return _coin.SoExtSelection_isUsingOverlay(self)

    def getOverlaySceneGraph(self):
        r"""getOverlaySceneGraph(SoExtSelection self) -> SoSeparator"""
        return _coin.SoExtSelection_getOverlaySceneGraph(self)

    def setOverlayLassoColorIndex(self, index):
        r"""setOverlayLassoColorIndex(SoExtSelection self, int const index)"""
        return _coin.SoExtSelection_setOverlayLassoColorIndex(self, index)

    def getOverlayLassoColorIndex(self):
        r"""getOverlayLassoColorIndex(SoExtSelection self) -> int"""
        return _coin.SoExtSelection_getOverlayLassoColorIndex(self)

    def setLassoColor(self, color):
        r"""setLassoColor(SoExtSelection self, SbColor color)"""
        return _coin.SoExtSelection_setLassoColor(self, color)

    def getLassoColor(self):
        r"""getLassoColor(SoExtSelection self) -> SbColor"""
        return _coin.SoExtSelection_getLassoColor(self)

    def setLassoWidth(self, width):
        r"""setLassoWidth(SoExtSelection self, float const width)"""
        return _coin.SoExtSelection_setLassoWidth(self, width)

    def getLassoWidth(self):
        r"""getLassoWidth(SoExtSelection self) -> float"""
        return _coin.SoExtSelection_getLassoWidth(self)

    def setOverlayLassoPattern(self, pattern):
        r"""setOverlayLassoPattern(SoExtSelection self, unsigned short const pattern)"""
        return _coin.SoExtSelection_setOverlayLassoPattern(self, pattern)

    def getOverlayLassoPattern(self):
        r"""getOverlayLassoPattern(SoExtSelection self) -> unsigned short"""
        return _coin.SoExtSelection_getOverlayLassoPattern(self)

    def animateOverlayLasso(self, animate=1):
        r"""animateOverlayLasso(SoExtSelection self, SbBool const animate=1)"""
        return _coin.SoExtSelection_animateOverlayLasso(self, animate)

    def isOverlayLassoAnimated(self):
        r"""isOverlayLassoAnimated(SoExtSelection self) -> SbBool"""
        return _coin.SoExtSelection_isOverlayLassoAnimated(self)

    def handleEvent(self, action):
        r"""handleEvent(SoExtSelection self, SoHandleEventAction action)"""
        return _coin.SoExtSelection_handleEvent(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoExtSelection self, SoGLRenderAction action)"""
        return _coin.SoExtSelection_GLRenderBelowPath(self, action)

    def select(self, *args):
        r"""
        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):
        r"""getLassoCoordsDC(SoExtSelection self, int & numCoords) -> SbVec2s"""
        return _coin.SoExtSelection_getLassoCoordsDC(self, numCoords)

    def getLassoCoordsWC(self, numCoords):
        r"""getLassoCoordsWC(SoExtSelection self, int & numCoords) -> SbVec3f"""
        return _coin.SoExtSelection_getLassoCoordsWC(self, numCoords)

    def getSelectionPathList(self):
        r"""getSelectionPathList(SoExtSelection self) -> SoPathList"""
        return _coin.SoExtSelection_getSelectionPathList(self)

    def setLassoFilterCallback(self, f, userdata=None, callonlyifselectable=1):
        r"""setLassoFilterCallback(SoExtSelection self, SoLassoSelectionFilterCB * f, void * userdata=None, SbBool const callonlyifselectable=1)"""
        return _coin.SoExtSelection_setLassoFilterCallback(self, f, userdata, callonlyifselectable)

    def setTriangleFilterCallback(self, func, userdata=None):
        r"""setTriangleFilterCallback(SoExtSelection self, SoExtSelectionTriangleCB * func, void * userdata=None)"""
        return _coin.SoExtSelection_setTriangleFilterCallback(self, func, userdata)

    def setLineSegmentFilterCallback(self, func, userdata=None):
        r"""setLineSegmentFilterCallback(SoExtSelection self, SoExtSelectionLineSegmentCB * func, void * userdata=None)"""
        return _coin.SoExtSelection_setLineSegmentFilterCallback(self, func, userdata)

    def setPointFilterCallback(self, func, userdata=None):
        r"""setPointFilterCallback(SoExtSelection self, SoExtSelectionPointCB * func, void * userdata=None)"""
        return _coin.SoExtSelection_setPointFilterCallback(self, func, userdata)

    def wasShiftDown(self):
        r"""wasShiftDown(SoExtSelection self) -> SbBool"""
        return _coin.SoExtSelection_wasShiftDown(self)

# Register SoExtSelection in _coin:
_coin.SoExtSelection_swigregister(SoExtSelection)
class SoVertexProperty(SoNode):
    r"""Proxy of C++ SoVertexProperty class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexProperty_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVertexProperty self) -> SoType"""
        return _coin.SoVertexProperty_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVertexProperty_initClass()

    def __init__(self):
        r"""__init__(SoVertexProperty self) -> SoVertexProperty"""
        _coin.SoVertexProperty_swiginit(self, _coin.new_SoVertexProperty())
    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 = property(_coin.SoVertexProperty_vertex_get, _coin.SoVertexProperty_vertex_set, doc=r"""vertex : SoMFVec3f""")
    texCoord = property(_coin.SoVertexProperty_texCoord_get, _coin.SoVertexProperty_texCoord_set, doc=r"""texCoord : SoMFVec2f""")
    texCoord3 = property(_coin.SoVertexProperty_texCoord3_get, _coin.SoVertexProperty_texCoord3_set, doc=r"""texCoord3 : SoMFVec3f""")
    normal = property(_coin.SoVertexProperty_normal_get, _coin.SoVertexProperty_normal_set, doc=r"""normal : SoMFVec3f""")
    normalBinding = property(_coin.SoVertexProperty_normalBinding_get, _coin.SoVertexProperty_normalBinding_set, doc=r"""normalBinding : SoSFEnum""")
    orderedRGBA = property(_coin.SoVertexProperty_orderedRGBA_get, _coin.SoVertexProperty_orderedRGBA_set, doc=r"""orderedRGBA : SoMFUInt32""")
    materialBinding = property(_coin.SoVertexProperty_materialBinding_get, _coin.SoVertexProperty_materialBinding_set, doc=r"""materialBinding : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoVertexProperty self, SoAction action)"""
        return _coin.SoVertexProperty_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVertexProperty self, SoGLRenderAction action)"""
        return _coin.SoVertexProperty_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVertexProperty self, SoGetBoundingBoxAction action)"""
        return _coin.SoVertexProperty_getBoundingBox(self, action)

    def callback(self, action):
        r"""callback(SoVertexProperty self, SoCallbackAction action)"""
        return _coin.SoVertexProperty_callback(self, action)

    def pick(self, action):
        r"""pick(SoVertexProperty self, SoPickAction action)"""
        return _coin.SoVertexProperty_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVertexProperty self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVertexProperty_getPrimitiveCount(self, action)

# Register SoVertexProperty in _coin:
_coin.SoVertexProperty_swigregister(SoVertexProperty)
class SoVertexShape(SoShape):
    r"""Proxy of C++ SoVertexShape class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexShape_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVertexShape self) -> SoType"""
        return _coin.SoVertexShape_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVertexShape_initClass()
    vertexProperty = property(_coin.SoVertexShape_vertexProperty_get, _coin.SoVertexShape_vertexProperty_set, doc=r"""vertexProperty : SoSFNode""")

    def notify(self, nl):
        r"""notify(SoVertexShape self, SoNotList nl)"""
        return _coin.SoVertexShape_notify(self, nl)

    def generateDefaultNormals(self, *args):
        r"""
        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):
        r"""write(SoVertexShape self, SoWriteAction action)"""
        return _coin.SoVertexShape_write(self, action)

# Register SoVertexShape in _coin:
_coin.SoVertexShape_swigregister(SoVertexShape)
class SoNonIndexedShape(SoVertexShape):
    r"""Proxy of C++ SoNonIndexedShape class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNonIndexedShape_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoNonIndexedShape self) -> SoType"""
        return _coin.SoNonIndexedShape_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNonIndexedShape_initClass()
    startIndex = property(_coin.SoNonIndexedShape_startIndex_get, _coin.SoNonIndexedShape_startIndex_set, doc=r"""startIndex : SoSFInt32""")

# Register SoNonIndexedShape in _coin:
_coin.SoNonIndexedShape_swigregister(SoNonIndexedShape)
class SoFaceSet(SoNonIndexedShape):
    r"""Proxy of C++ SoFaceSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFaceSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoFaceSet self) -> SoType"""
        return _coin.SoFaceSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFaceSet_initClass()

    def __init__(self):
        r"""__init__(SoFaceSet self) -> SoFaceSet"""
        _coin.SoFaceSet_swiginit(self, _coin.new_SoFaceSet())
    numVertices = property(_coin.SoFaceSet_numVertices_get, _coin.SoFaceSet_numVertices_set, doc=r"""numVertices : SoMFInt32""")

    def GLRender(self, action):
        r"""GLRender(SoFaceSet self, SoGLRenderAction action)"""
        return _coin.SoFaceSet_GLRender(self, action)

    def generateDefaultNormals(self, state, nb):
        r"""generateDefaultNormals(SoFaceSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoFaceSet_generateDefaultNormals(self, state, nb)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFaceSet_getPrimitiveCount(self, action)

# Register SoFaceSet in _coin:
_coin.SoFaceSet_swigregister(SoFaceSet)
class SoFile(SoNode):
    r"""Proxy of C++ SoFile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFile_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoFile self) -> SoType"""
        return _coin.SoFile_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFile_initClass()

    def __init__(self):
        r"""__init__(SoFile self) -> SoFile"""
        _coin.SoFile_swiginit(self, _coin.new_SoFile())
    name = property(_coin.SoFile_name_get, _coin.SoFile_name_set, doc=r"""name : SoSFString""")

    def doAction(self, action):
        r"""doAction(SoFile self, SoAction action)"""
        return _coin.SoFile_doAction(self, action)

    def callback(self, action):
        r"""callback(SoFile self, SoCallbackAction action)"""
        return _coin.SoFile_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoFile self, SoGLRenderAction action)"""
        return _coin.SoFile_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoFile self, SoGetBoundingBoxAction action)"""
        return _coin.SoFile_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoFile self, SoGetMatrixAction action)"""
        return _coin.SoFile_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoFile self, SoHandleEventAction action)"""
        return _coin.SoFile_handleEvent(self, action)

    def pick(self, action):
        r"""pick(SoFile self, SoPickAction action)"""
        return _coin.SoFile_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoFile self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFile_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoFile self, SoAudioRenderAction action)"""
        return _coin.SoFile_audioRender(self, action)

    def search(self, action):
        r"""search(SoFile self, SoSearchAction action)"""
        return _coin.SoFile_search(self, action)

    def copyChildren(self):
        r"""copyChildren(SoFile self) -> SoGroup"""
        return _coin.SoFile_copyChildren(self)

    def getChildren(self):
        r"""getChildren(SoFile self) -> SoChildList"""
        return _coin.SoFile_getChildren(self)

    def copyContents(self, srcFrom, copyconnections):
        r"""copyContents(SoFile self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoFile_copyContents(self, srcFrom, copyconnections)

    def getFullName(self):
        r"""getFullName(SoFile self) -> SbString"""
        return _coin.SoFile_getFullName(self)

    @staticmethod
    def setSearchOK(dosearch):
        r"""setSearchOK(SbBool dosearch)"""
        return _coin.SoFile_setSearchOK(dosearch)

    @staticmethod
    def getSearchOK():
        r"""getSearchOK() -> SbBool"""
        return _coin.SoFile_getSearchOK()

# Register SoFile in _coin:
_coin.SoFile_swigregister(SoFile)
class SoFont(SoNode):
    r"""Proxy of C++ SoFont class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFont_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoFont self) -> SoType"""
        return _coin.SoFont_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFont_initClass()

    def __init__(self):
        r"""__init__(SoFont self) -> SoFont"""
        _coin.SoFont_swiginit(self, _coin.new_SoFont())
    name = property(_coin.SoFont_name_get, _coin.SoFont_name_set, doc=r"""name : SoSFName""")
    size = property(_coin.SoFont_size_get, _coin.SoFont_size_set, doc=r"""size : SoSFFloat""")

    def doAction(self, action):
        r"""doAction(SoFont self, SoAction action)"""
        return _coin.SoFont_doAction(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoFont self, SoGetBoundingBoxAction action)"""
        return _coin.SoFont_getBoundingBox(self, action)

    def GLRender(self, action):
        r"""GLRender(SoFont self, SoGLRenderAction action)"""
        return _coin.SoFont_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoFont self, SoCallbackAction action)"""
        return _coin.SoFont_callback(self, action)

    def pick(self, action):
        r"""pick(SoFont self, SoPickAction action)"""
        return _coin.SoFont_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoFont self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFont_getPrimitiveCount(self, action)

# Register SoFont in _coin:
_coin.SoFont_swigregister(SoFont)
class SoFontStyle(SoFont):
    r"""Proxy of C++ SoFontStyle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFontStyle_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoFontStyle self) -> SoType"""
        return _coin.SoFontStyle_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFontStyle_initClass()

    def __init__(self):
        r"""__init__(SoFontStyle self) -> SoFontStyle"""
        _coin.SoFontStyle_swiginit(self, _coin.new_SoFontStyle())
    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 = property(_coin.SoFontStyle_family_get, _coin.SoFontStyle_family_set, doc=r"""family : SoSFEnum""")
    style = property(_coin.SoFontStyle_style_get, _coin.SoFontStyle_style_set, doc=r"""style : SoSFBitMask""")

    def getFontName(self):
        r"""getFontName(SoFontStyle self) -> SbString"""
        return _coin.SoFontStyle_getFontName(self)

    def doAction(self, action):
        r"""doAction(SoFontStyle self, SoAction action)"""
        return _coin.SoFontStyle_doAction(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoFontStyle self, SoGetBoundingBoxAction action)"""
        return _coin.SoFontStyle_getBoundingBox(self, action)

    def GLRender(self, action):
        r"""GLRender(SoFontStyle self, SoGLRenderAction action)"""
        return _coin.SoFontStyle_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoFontStyle self, SoCallbackAction action)"""
        return _coin.SoFontStyle_callback(self, action)

    def pick(self, action):
        r"""pick(SoFontStyle self, SoPickAction action)"""
        return _coin.SoFontStyle_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoFontStyle self, SoGetPrimitiveCountAction action)"""
        return _coin.SoFontStyle_getPrimitiveCount(self, action)

# Register SoFontStyle in _coin:
_coin.SoFontStyle_swigregister(SoFontStyle)
class SoIndexedShape(SoVertexShape):
    r"""Proxy of C++ SoIndexedShape class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedShape_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoIndexedShape self) -> SoType"""
        return _coin.SoIndexedShape_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIndexedShape_initClass()
    coordIndex = property(_coin.SoIndexedShape_coordIndex_get, _coin.SoIndexedShape_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    materialIndex = property(_coin.SoIndexedShape_materialIndex_get, _coin.SoIndexedShape_materialIndex_set, doc=r"""materialIndex : SoMFInt32""")
    normalIndex = property(_coin.SoIndexedShape_normalIndex_get, _coin.SoIndexedShape_normalIndex_set, doc=r"""normalIndex : SoMFInt32""")
    textureCoordIndex = property(_coin.SoIndexedShape_textureCoordIndex_get, _coin.SoIndexedShape_textureCoordIndex_set, doc=r"""textureCoordIndex : SoMFInt32""")

# Register SoIndexedShape in _coin:
_coin.SoIndexedShape_swigregister(SoIndexedShape)
SO_END_FACE_INDEX = _coin.SO_END_FACE_INDEX

class SoIndexedFaceSet(SoIndexedShape):
    r"""Proxy of C++ SoIndexedFaceSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedFaceSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoIndexedFaceSet self) -> SoType"""
        return _coin.SoIndexedFaceSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIndexedFaceSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedFaceSet self) -> SoIndexedFaceSet"""
        _coin.SoIndexedFaceSet_swiginit(self, _coin.new_SoIndexedFaceSet())

    def GLRender(self, action):
        r"""GLRender(SoIndexedFaceSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedFaceSet_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoIndexedFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedFaceSet_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, *args):
        r"""
        generateDefaultNormals(SoIndexedFaceSet self, SoState state, SoNormalBundle bundle) -> SbBool
        generateDefaultNormals(SoIndexedFaceSet self, SoState state, SoNormalCache cache) -> SbBool
        """
        return _coin.SoIndexedFaceSet_generateDefaultNormals(self, *args)

# Register SoIndexedFaceSet in _coin:
_coin.SoIndexedFaceSet_swigregister(SoIndexedFaceSet)
SO_END_LINE_INDEX = _coin.SO_END_LINE_INDEX

class SoIndexedLineSet(SoIndexedShape):
    r"""Proxy of C++ SoIndexedLineSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedLineSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoIndexedLineSet self) -> SoType"""
        return _coin.SoIndexedLineSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIndexedLineSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedLineSet self) -> SoIndexedLineSet"""
        _coin.SoIndexedLineSet_swiginit(self, _coin.new_SoIndexedLineSet())

    def GLRender(self, action):
        r"""GLRender(SoIndexedLineSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedLineSet_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoIndexedLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedLineSet_getBoundingBox(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoIndexedLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedLineSet_getPrimitiveCount(self, action)

# Register SoIndexedLineSet in _coin:
_coin.SoIndexedLineSet_swigregister(SoIndexedLineSet)
class SoIndexedNurbsCurve(SoShape):
    r"""Proxy of C++ SoIndexedNurbsCurve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedNurbsCurve_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoIndexedNurbsCurve self) -> SoType"""
        return _coin.SoIndexedNurbsCurve_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIndexedNurbsCurve_initClass()

    def __init__(self):
        r"""__init__(SoIndexedNurbsCurve self) -> SoIndexedNurbsCurve"""
        _coin.SoIndexedNurbsCurve_swiginit(self, _coin.new_SoIndexedNurbsCurve())
    numControlPoints = property(_coin.SoIndexedNurbsCurve_numControlPoints_get, _coin.SoIndexedNurbsCurve_numControlPoints_set, doc=r"""numControlPoints : SoSFInt32""")
    coordIndex = property(_coin.SoIndexedNurbsCurve_coordIndex_get, _coin.SoIndexedNurbsCurve_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    knotVector = property(_coin.SoIndexedNurbsCurve_knotVector_get, _coin.SoIndexedNurbsCurve_knotVector_set, doc=r"""knotVector : SoMFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoIndexedNurbsCurve self, SoGLRenderAction action)"""
        return _coin.SoIndexedNurbsCurve_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoIndexedNurbsCurve self, SoRayPickAction action)"""
        return _coin.SoIndexedNurbsCurve_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoIndexedNurbsCurve self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedNurbsCurve_getPrimitiveCount(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoIndexedNurbsCurve self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedNurbsCurve_getBoundingBox(self, action)

    def sendPrimitive(self, arg2, arg3):
        r"""sendPrimitive(SoIndexedNurbsCurve self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoIndexedNurbsCurve_sendPrimitive(self, arg2, arg3)

# Register SoIndexedNurbsCurve in _coin:
_coin.SoIndexedNurbsCurve_swigregister(SoIndexedNurbsCurve)
class SoIndexedNurbsSurface(SoShape):
    r"""Proxy of C++ SoIndexedNurbsSurface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedNurbsSurface_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoIndexedNurbsSurface self) -> SoType"""
        return _coin.SoIndexedNurbsSurface_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIndexedNurbsSurface_initClass()

    def __init__(self):
        r"""__init__(SoIndexedNurbsSurface self) -> SoIndexedNurbsSurface"""
        _coin.SoIndexedNurbsSurface_swiginit(self, _coin.new_SoIndexedNurbsSurface())
    numUControlPoints = property(_coin.SoIndexedNurbsSurface_numUControlPoints_get, _coin.SoIndexedNurbsSurface_numUControlPoints_set, doc=r"""numUControlPoints : SoSFInt32""")
    numVControlPoints = property(_coin.SoIndexedNurbsSurface_numVControlPoints_get, _coin.SoIndexedNurbsSurface_numVControlPoints_set, doc=r"""numVControlPoints : SoSFInt32""")
    coordIndex = property(_coin.SoIndexedNurbsSurface_coordIndex_get, _coin.SoIndexedNurbsSurface_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    uKnotVector = property(_coin.SoIndexedNurbsSurface_uKnotVector_get, _coin.SoIndexedNurbsSurface_uKnotVector_set, doc=r"""uKnotVector : SoMFFloat""")
    vKnotVector = property(_coin.SoIndexedNurbsSurface_vKnotVector_get, _coin.SoIndexedNurbsSurface_vKnotVector_set, doc=r"""vKnotVector : SoMFFloat""")
    numSControlPoints = property(_coin.SoIndexedNurbsSurface_numSControlPoints_get, _coin.SoIndexedNurbsSurface_numSControlPoints_set, doc=r"""numSControlPoints : SoSFInt32""")
    numTControlPoints = property(_coin.SoIndexedNurbsSurface_numTControlPoints_get, _coin.SoIndexedNurbsSurface_numTControlPoints_set, doc=r"""numTControlPoints : SoSFInt32""")
    textureCoordIndex = property(_coin.SoIndexedNurbsSurface_textureCoordIndex_get, _coin.SoIndexedNurbsSurface_textureCoordIndex_set, doc=r"""textureCoordIndex : SoMFInt32""")
    sKnotVector = property(_coin.SoIndexedNurbsSurface_sKnotVector_get, _coin.SoIndexedNurbsSurface_sKnotVector_set, doc=r"""sKnotVector : SoMFFloat""")
    tKnotVector = property(_coin.SoIndexedNurbsSurface_tKnotVector_get, _coin.SoIndexedNurbsSurface_tKnotVector_set, doc=r"""tKnotVector : SoMFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoIndexedNurbsSurface self, SoGLRenderAction action)"""
        return _coin.SoIndexedNurbsSurface_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoIndexedNurbsSurface self, SoRayPickAction action)"""
        return _coin.SoIndexedNurbsSurface_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoIndexedNurbsSurface self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedNurbsSurface_getPrimitiveCount(self, action)

    def sendPrimitive(self, arg2, arg3):
        r"""sendPrimitive(SoIndexedNurbsSurface self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoIndexedNurbsSurface_sendPrimitive(self, arg2, arg3)

# Register SoIndexedNurbsSurface in _coin:
_coin.SoIndexedNurbsSurface_swigregister(SoIndexedNurbsSurface)
SO_END_STRIP_INDEX = _coin.SO_END_STRIP_INDEX

class SoIndexedTriangleStripSet(SoIndexedShape):
    r"""Proxy of C++ SoIndexedTriangleStripSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedTriangleStripSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoIndexedTriangleStripSet self) -> SoType"""
        return _coin.SoIndexedTriangleStripSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIndexedTriangleStripSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedTriangleStripSet self) -> SoIndexedTriangleStripSet"""
        _coin.SoIndexedTriangleStripSet_swiginit(self, _coin.new_SoIndexedTriangleStripSet())

    def GLRender(self, action):
        r"""GLRender(SoIndexedTriangleStripSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedTriangleStripSet_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoIndexedTriangleStripSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedTriangleStripSet_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, state, nb):
        r"""generateDefaultNormals(SoIndexedTriangleStripSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoIndexedTriangleStripSet_generateDefaultNormals(self, state, nb)

# Register SoIndexedTriangleStripSet in _coin:
_coin.SoIndexedTriangleStripSet_swigregister(SoIndexedTriangleStripSet)
class SoInfo(SoNode):
    r"""Proxy of C++ SoInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoInfo_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoInfo self) -> SoType"""
        return _coin.SoInfo_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoInfo_initClass()

    def __init__(self):
        r"""__init__(SoInfo self) -> SoInfo"""
        _coin.SoInfo_swiginit(self, _coin.new_SoInfo())
    string = property(_coin.SoInfo_string_get, _coin.SoInfo_string_set, doc=r"""string : SoSFString""")

# Register SoInfo in _coin:
_coin.SoInfo_swigregister(SoInfo)
class SoLabel(SoNode):
    r"""Proxy of C++ SoLabel class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLabel_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLabel self) -> SoType"""
        return _coin.SoLabel_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLabel_initClass()

    def __init__(self):
        r"""__init__(SoLabel self) -> SoLabel"""
        _coin.SoLabel_swiginit(self, _coin.new_SoLabel())
    label = property(_coin.SoLabel_label_get, _coin.SoLabel_label_set, doc=r"""label : SoSFName""")

# Register SoLabel in _coin:
_coin.SoLabel_swigregister(SoLabel)
class SoLevelOfDetail(SoGroup):
    r"""Proxy of C++ SoLevelOfDetail class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLevelOfDetail_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLevelOfDetail self) -> SoType"""
        return _coin.SoLevelOfDetail_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLevelOfDetail_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoLevelOfDetail self) -> SoLevelOfDetail
        __init__(SoLevelOfDetail self, int numchildren) -> SoLevelOfDetail
        """
        _coin.SoLevelOfDetail_swiginit(self, _coin.new_SoLevelOfDetail(*args))
    screenArea = property(_coin.SoLevelOfDetail_screenArea_get, _coin.SoLevelOfDetail_screenArea_set, doc=r"""screenArea : SoMFFloat""")

    def doAction(self, action):
        r"""doAction(SoLevelOfDetail self, SoAction action)"""
        return _coin.SoLevelOfDetail_doAction(self, action)

    def callback(self, action):
        r"""callback(SoLevelOfDetail self, SoCallbackAction action)"""
        return _coin.SoLevelOfDetail_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoLevelOfDetail self, SoGLRenderAction action)"""
        return _coin.SoLevelOfDetail_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoLevelOfDetail self, SoRayPickAction action)"""
        return _coin.SoLevelOfDetail_rayPick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoLevelOfDetail self, SoGetBoundingBoxAction action)"""
        return _coin.SoLevelOfDetail_getBoundingBox(self, action)

    def audioRender(self, action):
        r"""audioRender(SoLevelOfDetail self, SoAudioRenderAction action)"""
        return _coin.SoLevelOfDetail_audioRender(self, action)

    def notify(self, nl):
        r"""notify(SoLevelOfDetail self, SoNotList nl)"""
        return _coin.SoLevelOfDetail_notify(self, nl)

# Register SoLevelOfDetail in _coin:
_coin.SoLevelOfDetail_swigregister(SoLevelOfDetail)
class SoProfile(SoNode):
    r"""Proxy of C++ SoProfile class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfile_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoProfile self) -> SoType"""
        return _coin.SoProfile_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoProfile_initClass()
    START_FIRST = _coin.SoProfile_START_FIRST
    
    START_NEW = _coin.SoProfile_START_NEW
    
    ADD_TO_CURRENT = _coin.SoProfile_ADD_TO_CURRENT
    
    index = property(_coin.SoProfile_index_get, _coin.SoProfile_index_set, doc=r"""index : SoMFInt32""")
    linkage = property(_coin.SoProfile_linkage_get, _coin.SoProfile_linkage_set, doc=r"""linkage : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoProfile self, SoAction action)"""
        return _coin.SoProfile_doAction(self, action)

    def callback(self, action):
        r"""callback(SoProfile self, SoCallbackAction action)"""
        return _coin.SoProfile_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoProfile self, SoGLRenderAction action)"""
        return _coin.SoProfile_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoProfile self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfile_getBoundingBox(self, action)

    def pick(self, action):
        r"""pick(SoProfile self, SoPickAction action)"""
        return _coin.SoProfile_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoProfile self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfile_getPrimitiveCount(self, action)

    def getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector):
        r"""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):
        r"""getVertices(SoProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoProfile_getVertices(self, state, numvertices, vertices)

# Register SoProfile in _coin:
_coin.SoProfile_swigregister(SoProfile)
class SoLinearProfile(SoProfile):
    r"""Proxy of C++ SoLinearProfile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLinearProfile_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLinearProfile self) -> SoType"""
        return _coin.SoLinearProfile_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLinearProfile_initClass()

    def __init__(self):
        r"""__init__(SoLinearProfile self) -> SoLinearProfile"""
        _coin.SoLinearProfile_swiginit(self, _coin.new_SoLinearProfile())

    def getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector):
        r"""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):
        r"""getVertices(SoLinearProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoLinearProfile_getVertices(self, state, numvertices, vertices)

# Register SoLinearProfile in _coin:
_coin.SoLinearProfile_swigregister(SoLinearProfile)
class SoLineSet(SoNonIndexedShape):
    r"""Proxy of C++ SoLineSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLineSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLineSet self) -> SoType"""
        return _coin.SoLineSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLineSet_initClass()

    def __init__(self):
        r"""__init__(SoLineSet self) -> SoLineSet"""
        _coin.SoLineSet_swiginit(self, _coin.new_SoLineSet())
    numVertices = property(_coin.SoLineSet_numVertices_get, _coin.SoLineSet_numVertices_set, doc=r"""numVertices : SoMFInt32""")

    def GLRender(self, action):
        r"""GLRender(SoLineSet self, SoGLRenderAction action)"""
        return _coin.SoLineSet_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoLineSet_getBoundingBox(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoLineSet_getPrimitiveCount(self, action)

# Register SoLineSet in _coin:
_coin.SoLineSet_swigregister(SoLineSet)
class SoListener(SoNode):
    r"""Proxy of C++ SoListener class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoListener_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoListener self) -> SoType"""
        return _coin.SoListener_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoListener_initClass()

    def __init__(self):
        r"""__init__(SoListener self) -> SoListener"""
        _coin.SoListener_swiginit(self, _coin.new_SoListener())
    position = property(_coin.SoListener_position_get, _coin.SoListener_position_set, doc=r"""position : SoSFVec3f""")
    orientation = property(_coin.SoListener_orientation_get, _coin.SoListener_orientation_set, doc=r"""orientation : SoSFRotation""")
    gain = property(_coin.SoListener_gain_get, _coin.SoListener_gain_set, doc=r"""gain : SoSFFloat""")
    dopplerVelocity = property(_coin.SoListener_dopplerVelocity_get, _coin.SoListener_dopplerVelocity_set, doc=r"""dopplerVelocity : SoSFVec3f""")
    dopplerFactor = property(_coin.SoListener_dopplerFactor_get, _coin.SoListener_dopplerFactor_set, doc=r"""dopplerFactor : SoSFFloat""")

# Register SoListener in _coin:
_coin.SoListener_swigregister(SoListener)
class SoLocateHighlight(SoSeparator):
    r"""Proxy of C++ SoLocateHighlight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLocateHighlight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLocateHighlight self) -> SoType"""
        return _coin.SoLocateHighlight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLocateHighlight_initClass()

    def __init__(self):
        r"""__init__(SoLocateHighlight self) -> SoLocateHighlight"""
        _coin.SoLocateHighlight_swiginit(self, _coin.new_SoLocateHighlight())
    AUTO = _coin.SoLocateHighlight_AUTO
    
    ON = _coin.SoLocateHighlight_ON
    
    OFF = _coin.SoLocateHighlight_OFF
    
    EMISSIVE = _coin.SoLocateHighlight_EMISSIVE
    
    EMISSIVE_DIFFUSE = _coin.SoLocateHighlight_EMISSIVE_DIFFUSE
    
    color = property(_coin.SoLocateHighlight_color_get, _coin.SoLocateHighlight_color_set, doc=r"""color : SoSFColor""")
    style = property(_coin.SoLocateHighlight_style_get, _coin.SoLocateHighlight_style_set, doc=r"""style : SoSFEnum""")
    mode = property(_coin.SoLocateHighlight_mode_get, _coin.SoLocateHighlight_mode_set, doc=r"""mode : SoSFEnum""")

    def handleEvent(self, action):
        r"""handleEvent(SoLocateHighlight self, SoHandleEventAction action)"""
        return _coin.SoLocateHighlight_handleEvent(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoLocateHighlight self, SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action):
        r"""GLRenderInPath(SoLocateHighlight self, SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_GLRenderInPath(self, action)

    @staticmethod
    def turnOffCurrentHighlight(action):
        r"""turnOffCurrentHighlight(SoGLRenderAction action)"""
        return _coin.SoLocateHighlight_turnOffCurrentHighlight(action)

# Register SoLocateHighlight in _coin:
_coin.SoLocateHighlight_swigregister(SoLocateHighlight)
class SoLOD(SoGroup):
    r"""Proxy of C++ SoLOD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoLOD_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoLOD self) -> SoType"""
        return _coin.SoLOD_getTypeId(self)

    def __init__(self, *args):
        r"""
        __init__(SoLOD self) -> SoLOD
        __init__(SoLOD self, int numchildren) -> SoLOD
        """
        _coin.SoLOD_swiginit(self, _coin.new_SoLOD(*args))

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoLOD_initClass()
    range = property(_coin.SoLOD_range_get, _coin.SoLOD_range_set, doc=r"""range : SoMFFloat""")
    center = property(_coin.SoLOD_center_get, _coin.SoLOD_center_set, doc=r"""center : SoSFVec3f""")

    def doAction(self, action):
        r"""doAction(SoLOD self, SoAction action)"""
        return _coin.SoLOD_doAction(self, action)

    def callback(self, action):
        r"""callback(SoLOD self, SoCallbackAction action)"""
        return _coin.SoLOD_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRender(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action):
        r"""GLRenderInPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action):
        r"""GLRenderOffPath(SoLOD self, SoGLRenderAction action)"""
        return _coin.SoLOD_GLRenderOffPath(self, action)

    def rayPick(self, action):
        r"""rayPick(SoLOD self, SoRayPickAction action)"""
        return _coin.SoLOD_rayPick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoLOD self, SoGetBoundingBoxAction action)"""
        return _coin.SoLOD_getBoundingBox(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoLOD self, SoGetPrimitiveCountAction action)"""
        return _coin.SoLOD_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoLOD self, SoAudioRenderAction action)"""
        return _coin.SoLOD_audioRender(self, action)

    def notify(self, nl):
        r"""notify(SoLOD self, SoNotList nl)"""
        return _coin.SoLOD_notify(self, nl)

# Register SoLOD in _coin:
_coin.SoLOD_swigregister(SoLOD)
class SoPointSet(SoNonIndexedShape):
    r"""Proxy of C++ SoPointSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPointSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPointSet self) -> SoType"""
        return _coin.SoPointSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPointSet_initClass()

    def __init__(self):
        r"""__init__(SoPointSet self) -> SoPointSet"""
        _coin.SoPointSet_swiginit(self, _coin.new_SoPointSet())
    numPoints = property(_coin.SoPointSet_numPoints_get, _coin.SoPointSet_numPoints_set, doc=r"""numPoints : SoSFInt32""")

    def GLRender(self, action):
        r"""GLRender(SoPointSet self, SoGLRenderAction action)"""
        return _coin.SoPointSet_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoPointSet_getBoundingBox(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoPointSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoPointSet_getPrimitiveCount(self, action)

# Register SoPointSet in _coin:
_coin.SoPointSet_swigregister(SoPointSet)
class SoMarkerSet(SoPointSet):
    r"""Proxy of C++ SoMarkerSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMarkerSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMarkerSet self) -> SoType"""
        return _coin.SoMarkerSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMarkerSet_initClass()

    def __init__(self):
        r"""__init__(SoMarkerSet self) -> SoMarkerSet"""
        _coin.SoMarkerSet_swiginit(self, _coin.new_SoMarkerSet())
    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 = property(_coin.SoMarkerSet_markerIndex_get, _coin.SoMarkerSet_markerIndex_set, doc=r"""markerIndex : SoMFInt32""")

    def GLRender(self, action):
        r"""GLRender(SoMarkerSet self, SoGLRenderAction action)"""
        return _coin.SoMarkerSet_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoMarkerSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMarkerSet_getPrimitiveCount(self, action)

    @staticmethod
    def getNumDefinedMarkers():
        r"""getNumDefinedMarkers() -> int"""
        return _coin.SoMarkerSet_getNumDefinedMarkers()

    @staticmethod
    def getMarker(idx, size, bytes, isLSBFirst):
        r"""getMarker(int idx, SbVec2s size, unsigned char const *& bytes, SbBool & isLSBFirst) -> SbBool"""
        return _coin.SoMarkerSet_getMarker(idx, size, bytes, isLSBFirst)

    @staticmethod
    def removeMarker(idx):
        r"""removeMarker(int idx) -> SbBool"""
        return _coin.SoMarkerSet_removeMarker(idx)

    @staticmethod
    def isMarkerBitSet(idx, bitNumber):
        r"""isMarkerBitSet(int idx, int bitNumber) -> SbBool"""
        return _coin.SoMarkerSet_isMarkerBitSet(idx, bitNumber)

    @staticmethod
    def addMarker(*args):
        r"""
        addMarker(int idx, SbVec2s size, unsigned char const * bytes, SbBool isLSBFirst=1, SbBool isUpToDown=1)
        addMarker(int idx, SbVec2s size, PyObject * string, SbBool isLSBFirst=1, SbBool isUpToDown=1)
        """
        return _coin.SoMarkerSet_addMarker(*args)

# Register SoMarkerSet in _coin:
_coin.SoMarkerSet_swigregister(SoMarkerSet)
class SoMaterial(SoNode):
    r"""Proxy of C++ SoMaterial class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMaterial_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMaterial self) -> SoType"""
        return _coin.SoMaterial_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMaterial_initClass()

    def __init__(self):
        r"""__init__(SoMaterial self) -> SoMaterial"""
        _coin.SoMaterial_swiginit(self, _coin.new_SoMaterial())
    ambientColor = property(_coin.SoMaterial_ambientColor_get, _coin.SoMaterial_ambientColor_set, doc=r"""ambientColor : SoMFColor""")
    diffuseColor = property(_coin.SoMaterial_diffuseColor_get, _coin.SoMaterial_diffuseColor_set, doc=r"""diffuseColor : SoMFColor""")
    specularColor = property(_coin.SoMaterial_specularColor_get, _coin.SoMaterial_specularColor_set, doc=r"""specularColor : SoMFColor""")
    emissiveColor = property(_coin.SoMaterial_emissiveColor_get, _coin.SoMaterial_emissiveColor_set, doc=r"""emissiveColor : SoMFColor""")
    shininess = property(_coin.SoMaterial_shininess_get, _coin.SoMaterial_shininess_set, doc=r"""shininess : SoMFFloat""")
    transparency = property(_coin.SoMaterial_transparency_get, _coin.SoMaterial_transparency_set, doc=r"""transparency : SoMFFloat""")

    def doAction(self, action):
        r"""doAction(SoMaterial self, SoAction action)"""
        return _coin.SoMaterial_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoMaterial self, SoGLRenderAction action)"""
        return _coin.SoMaterial_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoMaterial self, SoCallbackAction action)"""
        return _coin.SoMaterial_callback(self, action)

# Register SoMaterial in _coin:
_coin.SoMaterial_swigregister(SoMaterial)
class SoMatrixTransform(SoTransformation):
    r"""Proxy of C++ SoMatrixTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMatrixTransform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMatrixTransform self) -> SoType"""
        return _coin.SoMatrixTransform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMatrixTransform_initClass()

    def __init__(self):
        r"""__init__(SoMatrixTransform self) -> SoMatrixTransform"""
        _coin.SoMatrixTransform_swiginit(self, _coin.new_SoMatrixTransform())
    matrix = property(_coin.SoMatrixTransform_matrix_get, _coin.SoMatrixTransform_matrix_set, doc=r"""matrix : SoSFMatrix""")

    def doAction(self, action):
        r"""doAction(SoMatrixTransform self, SoAction action)"""
        return _coin.SoMatrixTransform_doAction(self, action)

    def callback(self, action):
        r"""callback(SoMatrixTransform self, SoCallbackAction action)"""
        return _coin.SoMatrixTransform_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoMatrixTransform self, SoGLRenderAction action)"""
        return _coin.SoMatrixTransform_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoMatrixTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoMatrixTransform_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoMatrixTransform self, SoGetMatrixAction action)"""
        return _coin.SoMatrixTransform_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoMatrixTransform self, SoPickAction action)"""
        return _coin.SoMatrixTransform_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoMatrixTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMatrixTransform_getPrimitiveCount(self, action)

# Register SoMatrixTransform in _coin:
_coin.SoMatrixTransform_swigregister(SoMatrixTransform)
class SoMultipleCopy(SoGroup):
    r"""Proxy of C++ SoMultipleCopy class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoMultipleCopy_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoMultipleCopy self) -> SoType"""
        return _coin.SoMultipleCopy_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoMultipleCopy_initClass()

    def __init__(self):
        r"""__init__(SoMultipleCopy self) -> SoMultipleCopy"""
        _coin.SoMultipleCopy_swiginit(self, _coin.new_SoMultipleCopy())
    matrix = property(_coin.SoMultipleCopy_matrix_get, _coin.SoMultipleCopy_matrix_set, doc=r"""matrix : SoMFMatrix""")

    def affectsState(self):
        r"""affectsState(SoMultipleCopy self) -> SbBool"""
        return _coin.SoMultipleCopy_affectsState(self)

    def doAction(self, action):
        r"""doAction(SoMultipleCopy self, SoAction action)"""
        return _coin.SoMultipleCopy_doAction(self, action)

    def callback(self, action):
        r"""callback(SoMultipleCopy self, SoCallbackAction action)"""
        return _coin.SoMultipleCopy_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoMultipleCopy self, SoGLRenderAction action)"""
        return _coin.SoMultipleCopy_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoMultipleCopy self, SoPickAction action)"""
        return _coin.SoMultipleCopy_pick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoMultipleCopy self, SoGetBoundingBoxAction action)"""
        return _coin.SoMultipleCopy_getBoundingBox(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoMultipleCopy self, SoHandleEventAction action)"""
        return _coin.SoMultipleCopy_handleEvent(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoMultipleCopy self, SoGetMatrixAction action)"""
        return _coin.SoMultipleCopy_getMatrix(self, action)

    def search(self, action):
        r"""search(SoMultipleCopy self, SoSearchAction action)"""
        return _coin.SoMultipleCopy_search(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoMultipleCopy self, SoGetPrimitiveCountAction action)"""
        return _coin.SoMultipleCopy_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoMultipleCopy self, SoAudioRenderAction action)"""
        return _coin.SoMultipleCopy_audioRender(self, action)

# Register SoMultipleCopy in _coin:
_coin.SoMultipleCopy_swigregister(SoMultipleCopy)
class SoPerspectiveCamera(SoCamera):
    r"""Proxy of C++ SoPerspectiveCamera class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPerspectiveCamera_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPerspectiveCamera self) -> SoType"""
        return _coin.SoPerspectiveCamera_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPerspectiveCamera_initClass()

    def __init__(self):
        r"""__init__(SoPerspectiveCamera self) -> SoPerspectiveCamera"""
        _coin.SoPerspectiveCamera_swiginit(self, _coin.new_SoPerspectiveCamera())
    heightAngle = property(_coin.SoPerspectiveCamera_heightAngle_get, _coin.SoPerspectiveCamera_heightAngle_set, doc=r"""heightAngle : SoSFFloat""")

    def scaleHeight(self, scalefactor):
        r"""scaleHeight(SoPerspectiveCamera self, float scalefactor)"""
        return _coin.SoPerspectiveCamera_scaleHeight(self, scalefactor)

    def getViewVolume(self, useaspectratio=0.0):
        r"""getViewVolume(SoPerspectiveCamera self, float useaspectratio=0.0) -> SbViewVolume"""
        return _coin.SoPerspectiveCamera_getViewVolume(self, useaspectratio)

# Register SoPerspectiveCamera in _coin:
_coin.SoPerspectiveCamera_swigregister(SoPerspectiveCamera)
class SoOrthographicCamera(SoCamera):
    r"""Proxy of C++ SoOrthographicCamera class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoOrthographicCamera_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoOrthographicCamera self) -> SoType"""
        return _coin.SoOrthographicCamera_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoOrthographicCamera_initClass()

    def __init__(self):
        r"""__init__(SoOrthographicCamera self) -> SoOrthographicCamera"""
        _coin.SoOrthographicCamera_swiginit(self, _coin.new_SoOrthographicCamera())
    height = property(_coin.SoOrthographicCamera_height_get, _coin.SoOrthographicCamera_height_set, doc=r"""height : SoSFFloat""")

    def scaleHeight(self, scalefactor):
        r"""scaleHeight(SoOrthographicCamera self, float scalefactor)"""
        return _coin.SoOrthographicCamera_scaleHeight(self, scalefactor)

    def getViewVolume(self, useaspectratio=0.0):
        r"""getViewVolume(SoOrthographicCamera self, float useaspectratio=0.0) -> SbViewVolume"""
        return _coin.SoOrthographicCamera_getViewVolume(self, useaspectratio)

# Register SoOrthographicCamera in _coin:
_coin.SoOrthographicCamera_swigregister(SoOrthographicCamera)
class SoFrustumCamera(SoCamera):
    r"""Proxy of C++ SoFrustumCamera class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFrustumCamera_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoFrustumCamera self) -> SoType"""
        return _coin.SoFrustumCamera_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFrustumCamera_initClass()

    def __init__(self):
        r"""__init__(SoFrustumCamera self) -> SoFrustumCamera"""
        _coin.SoFrustumCamera_swiginit(self, _coin.new_SoFrustumCamera())
    left = property(_coin.SoFrustumCamera_left_get, _coin.SoFrustumCamera_left_set, doc=r"""left : SoSFFloat""")
    right = property(_coin.SoFrustumCamera_right_get, _coin.SoFrustumCamera_right_set, doc=r"""right : SoSFFloat""")
    top = property(_coin.SoFrustumCamera_top_get, _coin.SoFrustumCamera_top_set, doc=r"""top : SoSFFloat""")
    bottom = property(_coin.SoFrustumCamera_bottom_get, _coin.SoFrustumCamera_bottom_set, doc=r"""bottom : SoSFFloat""")

    def scaleHeight(self, scalefactor):
        r"""scaleHeight(SoFrustumCamera self, float scalefactor)"""
        return _coin.SoFrustumCamera_scaleHeight(self, scalefactor)

    def getViewVolume(self, useaspectratio=0.0):
        r"""getViewVolume(SoFrustumCamera self, float useaspectratio=0.0) -> SbViewVolume"""
        return _coin.SoFrustumCamera_getViewVolume(self, useaspectratio)

# Register SoFrustumCamera in _coin:
_coin.SoFrustumCamera_swigregister(SoFrustumCamera)
class SoQuadMesh(SoNonIndexedShape):
    r"""Proxy of C++ SoQuadMesh class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoQuadMesh_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQuadMesh self) -> SoType"""
        return _coin.SoQuadMesh_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoQuadMesh_initClass()

    def __init__(self):
        r"""__init__(SoQuadMesh self) -> SoQuadMesh"""
        _coin.SoQuadMesh_swiginit(self, _coin.new_SoQuadMesh())
    verticesPerColumn = property(_coin.SoQuadMesh_verticesPerColumn_get, _coin.SoQuadMesh_verticesPerColumn_set, doc=r"""verticesPerColumn : SoSFInt32""")
    verticesPerRow = property(_coin.SoQuadMesh_verticesPerRow_get, _coin.SoQuadMesh_verticesPerRow_set, doc=r"""verticesPerRow : SoSFInt32""")

    def GLRender(self, action):
        r"""GLRender(SoQuadMesh self, SoGLRenderAction action)"""
        return _coin.SoQuadMesh_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoQuadMesh self, SoGetPrimitiveCountAction action)"""
        return _coin.SoQuadMesh_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, state, nb):
        r"""generateDefaultNormals(SoQuadMesh self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoQuadMesh_generateDefaultNormals(self, state, nb)

# Register SoQuadMesh in _coin:
_coin.SoQuadMesh_swigregister(SoQuadMesh)
class SoTriangleStripSet(SoNonIndexedShape):
    r"""Proxy of C++ SoTriangleStripSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTriangleStripSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTriangleStripSet self) -> SoType"""
        return _coin.SoTriangleStripSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTriangleStripSet_initClass()

    def __init__(self):
        r"""__init__(SoTriangleStripSet self) -> SoTriangleStripSet"""
        _coin.SoTriangleStripSet_swiginit(self, _coin.new_SoTriangleStripSet())
    numVertices = property(_coin.SoTriangleStripSet_numVertices_get, _coin.SoTriangleStripSet_numVertices_set, doc=r"""numVertices : SoMFInt32""")

    def GLRender(self, action):
        r"""GLRender(SoTriangleStripSet self, SoGLRenderAction action)"""
        return _coin.SoTriangleStripSet_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoTriangleStripSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTriangleStripSet_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, state, nb):
        r"""generateDefaultNormals(SoTriangleStripSet self, SoState state, SoNormalBundle nb) -> SbBool"""
        return _coin.SoTriangleStripSet_generateDefaultNormals(self, state, nb)

# Register SoTriangleStripSet in _coin:
_coin.SoTriangleStripSet_swigregister(SoTriangleStripSet)
class SoIndexedPointSet(SoIndexedShape):
    r"""Proxy of C++ SoIndexedPointSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedPointSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoIndexedPointSet self) -> SoType"""
        return _coin.SoIndexedPointSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIndexedPointSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedPointSet self) -> SoIndexedPointSet"""
        _coin.SoIndexedPointSet_swiginit(self, _coin.new_SoIndexedPointSet())

    def GLRender(self, action):
        r"""GLRender(SoIndexedPointSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedPointSet_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoIndexedPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoIndexedPointSet_getBoundingBox(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoIndexedPointSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoIndexedPointSet_getPrimitiveCount(self, action)

    def notify(self, list):
        r"""notify(SoIndexedPointSet self, SoNotList list)"""
        return _coin.SoIndexedPointSet_notify(self, list)

# Register SoIndexedPointSet in _coin:
_coin.SoIndexedPointSet_swigregister(SoIndexedPointSet)
class SoIndexedMarkerSet(SoIndexedPointSet):
    r"""Proxy of C++ SoIndexedMarkerSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoIndexedMarkerSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoIndexedMarkerSet self) -> SoType"""
        return _coin.SoIndexedMarkerSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoIndexedMarkerSet_initClass()

    def __init__(self):
        r"""__init__(SoIndexedMarkerSet self) -> SoIndexedMarkerSet"""
        _coin.SoIndexedMarkerSet_swiginit(self, _coin.new_SoIndexedMarkerSet())
    markerIndex = property(_coin.SoIndexedMarkerSet_markerIndex_get, _coin.SoIndexedMarkerSet_markerIndex_set, doc=r"""markerIndex : SoMFInt32""")

    def GLRender(self, action):
        r"""GLRender(SoIndexedMarkerSet self, SoGLRenderAction action)"""
        return _coin.SoIndexedMarkerSet_GLRender(self, action)

    def notify(self, list):
        r"""notify(SoIndexedMarkerSet self, SoNotList list)"""
        return _coin.SoIndexedMarkerSet_notify(self, list)

# Register SoIndexedMarkerSet in _coin:
_coin.SoIndexedMarkerSet_swigregister(SoIndexedMarkerSet)
class SoNurbsCurve(SoShape):
    r"""Proxy of C++ SoNurbsCurve class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNurbsCurve_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoNurbsCurve self) -> SoType"""
        return _coin.SoNurbsCurve_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNurbsCurve_initClass()

    def __init__(self):
        r"""__init__(SoNurbsCurve self) -> SoNurbsCurve"""
        _coin.SoNurbsCurve_swiginit(self, _coin.new_SoNurbsCurve())
    numControlPoints = property(_coin.SoNurbsCurve_numControlPoints_get, _coin.SoNurbsCurve_numControlPoints_set, doc=r"""numControlPoints : SoSFInt32""")
    knotVector = property(_coin.SoNurbsCurve_knotVector_get, _coin.SoNurbsCurve_knotVector_set, doc=r"""knotVector : SoMFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoNurbsCurve self, SoGLRenderAction action)"""
        return _coin.SoNurbsCurve_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoNurbsCurve self, SoRayPickAction action)"""
        return _coin.SoNurbsCurve_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoNurbsCurve self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNurbsCurve_getPrimitiveCount(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoNurbsCurve self, SoGetBoundingBoxAction action)"""
        return _coin.SoNurbsCurve_getBoundingBox(self, action)

    def sendPrimitive(self, arg2, arg3):
        r"""sendPrimitive(SoNurbsCurve self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoNurbsCurve_sendPrimitive(self, arg2, arg3)

# Register SoNurbsCurve in _coin:
_coin.SoNurbsCurve_swigregister(SoNurbsCurve)
class SoNurbsSurface(SoShape):
    r"""Proxy of C++ SoNurbsSurface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNurbsSurface_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoNurbsSurface self) -> SoType"""
        return _coin.SoNurbsSurface_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNurbsSurface_initClass()

    def __init__(self):
        r"""__init__(SoNurbsSurface self) -> SoNurbsSurface"""
        _coin.SoNurbsSurface_swiginit(self, _coin.new_SoNurbsSurface())
    numUControlPoints = property(_coin.SoNurbsSurface_numUControlPoints_get, _coin.SoNurbsSurface_numUControlPoints_set, doc=r"""numUControlPoints : SoSFInt32""")
    numVControlPoints = property(_coin.SoNurbsSurface_numVControlPoints_get, _coin.SoNurbsSurface_numVControlPoints_set, doc=r"""numVControlPoints : SoSFInt32""")
    numSControlPoints = property(_coin.SoNurbsSurface_numSControlPoints_get, _coin.SoNurbsSurface_numSControlPoints_set, doc=r"""numSControlPoints : SoSFInt32""")
    numTControlPoints = property(_coin.SoNurbsSurface_numTControlPoints_get, _coin.SoNurbsSurface_numTControlPoints_set, doc=r"""numTControlPoints : SoSFInt32""")
    uKnotVector = property(_coin.SoNurbsSurface_uKnotVector_get, _coin.SoNurbsSurface_uKnotVector_set, doc=r"""uKnotVector : SoMFFloat""")
    vKnotVector = property(_coin.SoNurbsSurface_vKnotVector_get, _coin.SoNurbsSurface_vKnotVector_set, doc=r"""vKnotVector : SoMFFloat""")
    sKnotVector = property(_coin.SoNurbsSurface_sKnotVector_get, _coin.SoNurbsSurface_sKnotVector_set, doc=r"""sKnotVector : SoMFFloat""")
    tKnotVector = property(_coin.SoNurbsSurface_tKnotVector_get, _coin.SoNurbsSurface_tKnotVector_set, doc=r"""tKnotVector : SoMFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoNurbsSurface self, SoGLRenderAction action)"""
        return _coin.SoNurbsSurface_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoNurbsSurface self, SoRayPickAction action)"""
        return _coin.SoNurbsSurface_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoNurbsSurface self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNurbsSurface_getPrimitiveCount(self, action)

    def sendPrimitive(self, arg2, arg3):
        r"""sendPrimitive(SoNurbsSurface self, SoAction arg2, SoPrimitiveVertex arg3)"""
        return _coin.SoNurbsSurface_sendPrimitive(self, arg2, arg3)

# Register SoNurbsSurface in _coin:
_coin.SoNurbsSurface_swigregister(SoNurbsSurface)
class SoSphere(SoShape):
    r"""Proxy of C++ SoSphere class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSphere_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSphere self) -> SoType"""
        return _coin.SoSphere_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSphere_initClass()

    def __init__(self):
        r"""__init__(SoSphere self) -> SoSphere"""
        _coin.SoSphere_swiginit(self, _coin.new_SoSphere())
    radius = property(_coin.SoSphere_radius_get, _coin.SoSphere_radius_set, doc=r"""radius : SoSFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoSphere self, SoGLRenderAction action)"""
        return _coin.SoSphere_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoSphere self, SoRayPickAction action)"""
        return _coin.SoSphere_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoSphere self, SoGetPrimitiveCountAction action)"""
        return _coin.SoSphere_getPrimitiveCount(self, action)

# Register SoSphere in _coin:
_coin.SoSphere_swigregister(SoSphere)
class SoText2(SoShape):
    r"""Proxy of C++ SoText2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoText2_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoText2 self) -> SoType"""
        return _coin.SoText2_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoText2_initClass()

    def __init__(self):
        r"""__init__(SoText2 self) -> SoText2"""
        _coin.SoText2_swiginit(self, _coin.new_SoText2())
    LEFT = _coin.SoText2_LEFT
    
    RIGHT = _coin.SoText2_RIGHT
    
    CENTER = _coin.SoText2_CENTER
    
    string = property(_coin.SoText2_string_get, _coin.SoText2_string_set, doc=r"""string : SoMFString""")
    spacing = property(_coin.SoText2_spacing_get, _coin.SoText2_spacing_set, doc=r"""spacing : SoSFFloat""")
    justification = property(_coin.SoText2_justification_get, _coin.SoText2_justification_set, doc=r"""justification : SoSFEnum""")

    def GLRender(self, action):
        r"""GLRender(SoText2 self, SoGLRenderAction action)"""
        return _coin.SoText2_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoText2 self, SoRayPickAction action)"""
        return _coin.SoText2_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoText2 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoText2_getPrimitiveCount(self, action)

# Register SoText2 in _coin:
_coin.SoText2_swigregister(SoText2)
class SoText3(SoShape):
    r"""Proxy of C++ SoText3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoText3_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoText3 self) -> SoType"""
        return _coin.SoText3_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoText3_initClass()

    def __init__(self):
        r"""__init__(SoText3 self) -> SoText3"""
        _coin.SoText3_swiginit(self, _coin.new_SoText3())
    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 = property(_coin.SoText3_string_get, _coin.SoText3_string_set, doc=r"""string : SoMFString""")
    spacing = property(_coin.SoText3_spacing_get, _coin.SoText3_spacing_set, doc=r"""spacing : SoSFFloat""")
    justification = property(_coin.SoText3_justification_get, _coin.SoText3_justification_set, doc=r"""justification : SoSFEnum""")
    parts = property(_coin.SoText3_parts_get, _coin.SoText3_parts_set, doc=r"""parts : SoSFBitMask""")

    def getCharacterBounds(self, state, stringindex, charindex):
        r"""getCharacterBounds(SoText3 self, SoState state, int stringindex, int charindex) -> SbBox3f"""
        return _coin.SoText3_getCharacterBounds(self, state, stringindex, charindex)

    def GLRender(self, action):
        r"""GLRender(SoText3 self, SoGLRenderAction action)"""
        return _coin.SoText3_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoText3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoText3_getPrimitiveCount(self, action)

# Register SoText3 in _coin:
_coin.SoText3_swigregister(SoText3)
class SoWWWAnchor(SoLocateHighlight):
    r"""Proxy of C++ SoWWWAnchor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWWWAnchor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoWWWAnchor self) -> SoType"""
        return _coin.SoWWWAnchor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoWWWAnchor_initClass()

    def __init__(self):
        r"""__init__(SoWWWAnchor self) -> SoWWWAnchor"""
        _coin.SoWWWAnchor_swiginit(self, _coin.new_SoWWWAnchor())
    NONE = _coin.SoWWWAnchor_NONE
    
    POINT = _coin.SoWWWAnchor_POINT
    
    name = property(_coin.SoWWWAnchor_name_get, _coin.SoWWWAnchor_name_set, doc=r"""name : SoSFString""")
    description = property(_coin.SoWWWAnchor_description_get, _coin.SoWWWAnchor_description_set, doc=r"""description : SoSFString""")
    map = property(_coin.SoWWWAnchor_map_get, _coin.SoWWWAnchor_map_set, doc=r"""map : SoSFEnum""")

    def setFullURLName(self, url):
        r"""setFullURLName(SoWWWAnchor self, SbString url)"""
        return _coin.SoWWWAnchor_setFullURLName(self, url)

    def getFullURLName(self):
        r"""getFullURLName(SoWWWAnchor self) -> SbString"""
        return _coin.SoWWWAnchor_getFullURLName(self)

    def handleEvent(self, action):
        r"""handleEvent(SoWWWAnchor self, SoHandleEventAction action)"""
        return _coin.SoWWWAnchor_handleEvent(self, action)

    @staticmethod
    def setFetchURLCallBack(f, userData):
        r"""setFetchURLCallBack(SoWWWAnchorCB * f, void * userData)"""
        return _coin.SoWWWAnchor_setFetchURLCallBack(f, userData)

    @staticmethod
    def setHighlightURLCallBack(f, userData):
        r"""setHighlightURLCallBack(SoWWWAnchorCB * f, void * userData)"""
        return _coin.SoWWWAnchor_setHighlightURLCallBack(f, userData)

# Register SoWWWAnchor in _coin:
_coin.SoWWWAnchor_swigregister(SoWWWAnchor)
class SoPathSwitch(SoGroup):
    r"""Proxy of C++ SoPathSwitch class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPathSwitch_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPathSwitch self) -> SoType"""
        return _coin.SoPathSwitch_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPathSwitch_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoPathSwitch self) -> SoPathSwitch
        __init__(SoPathSwitch self, int numchildren) -> SoPathSwitch
        """
        _coin.SoPathSwitch_swiginit(self, _coin.new_SoPathSwitch(*args))
    path = property(_coin.SoPathSwitch_path_get, _coin.SoPathSwitch_path_set, doc=r"""path : SoSFPath""")

    def doAction(self, action):
        r"""doAction(SoPathSwitch self, SoAction action)"""
        return _coin.SoPathSwitch_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoPathSwitch self, SoGLRenderAction action)"""
        return _coin.SoPathSwitch_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoPathSwitch self, SoPickAction action)"""
        return _coin.SoPathSwitch_pick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoPathSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoPathSwitch_getBoundingBox(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoPathSwitch self, SoHandleEventAction action)"""
        return _coin.SoPathSwitch_handleEvent(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoPathSwitch self, SoGetMatrixAction action)"""
        return _coin.SoPathSwitch_getMatrix(self, action)

    def search(self, action):
        r"""search(SoPathSwitch self, SoSearchAction action)"""
        return _coin.SoPathSwitch_search(self, action)

    def callback(self, action):
        r"""callback(SoPathSwitch self, SoCallbackAction action)"""
        return _coin.SoPathSwitch_callback(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoPathSwitch self, SoGetPrimitiveCountAction action)"""
        return _coin.SoPathSwitch_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoPathSwitch self, SoAudioRenderAction action)"""
        return _coin.SoPathSwitch_audioRender(self, action)

# Register SoPathSwitch in _coin:
_coin.SoPathSwitch_swigregister(SoPathSwitch)
class SoTransformSeparator(SoGroup):
    r"""Proxy of C++ SoTransformSeparator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransformSeparator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransformSeparator self) -> SoType"""
        return _coin.SoTransformSeparator_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransformSeparator_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoTransformSeparator self) -> SoTransformSeparator
        __init__(SoTransformSeparator self, int nChildren) -> SoTransformSeparator
        """
        _coin.SoTransformSeparator_swiginit(self, _coin.new_SoTransformSeparator(*args))

    def doAction(self, action):
        r"""doAction(SoTransformSeparator self, SoAction action)"""
        return _coin.SoTransformSeparator_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTransformSeparator self, SoCallbackAction action)"""
        return _coin.SoTransformSeparator_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTransformSeparator self, SoGLRenderAction action)"""
        return _coin.SoTransformSeparator_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTransformSeparator self, SoPickAction action)"""
        return _coin.SoTransformSeparator_pick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoTransformSeparator self, SoGetBoundingBoxAction action)"""
        return _coin.SoTransformSeparator_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoTransformSeparator self, SoGetMatrixAction action)"""
        return _coin.SoTransformSeparator_getMatrix(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoTransformSeparator self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTransformSeparator_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoTransformSeparator self, SoAudioRenderAction action)"""
        return _coin.SoTransformSeparator_audioRender(self, action)

# Register SoTransformSeparator in _coin:
_coin.SoTransformSeparator_swigregister(SoTransformSeparator)
class SoRotation(SoTransformation):
    r"""Proxy of C++ SoRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoRotation self) -> SoType"""
        return _coin.SoRotation_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoRotation_initClass()

    def __init__(self):
        r"""__init__(SoRotation self) -> SoRotation"""
        _coin.SoRotation_swiginit(self, _coin.new_SoRotation())
    rotation = property(_coin.SoRotation_rotation_get, _coin.SoRotation_rotation_set, doc=r"""rotation : SoSFRotation""")

    def doAction(self, action):
        r"""doAction(SoRotation self, SoAction action)"""
        return _coin.SoRotation_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoRotation self, SoGLRenderAction action)"""
        return _coin.SoRotation_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoRotation self, SoCallbackAction action)"""
        return _coin.SoRotation_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoRotation self, SoGetBoundingBoxAction action)"""
        return _coin.SoRotation_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoRotation self, SoGetMatrixAction action)"""
        return _coin.SoRotation_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoRotation self, SoPickAction action)"""
        return _coin.SoRotation_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoRotation self, SoGetPrimitiveCountAction action)"""
        return _coin.SoRotation_getPrimitiveCount(self, action)

# Register SoRotation in _coin:
_coin.SoRotation_swigregister(SoRotation)
class SoPendulum(SoRotation):
    r"""Proxy of C++ SoPendulum class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPendulum_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPendulum self) -> SoType"""
        return _coin.SoPendulum_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPendulum_initClass()

    def __init__(self):
        r"""__init__(SoPendulum self) -> SoPendulum"""
        _coin.SoPendulum_swiginit(self, _coin.new_SoPendulum())
    rotation0 = property(_coin.SoPendulum_rotation0_get, _coin.SoPendulum_rotation0_set, doc=r"""rotation0 : SoSFRotation""")
    rotation1 = property(_coin.SoPendulum_rotation1_get, _coin.SoPendulum_rotation1_set, doc=r"""rotation1 : SoSFRotation""")
    speed = property(_coin.SoPendulum_speed_get, _coin.SoPendulum_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoPendulum_on_get, _coin.SoPendulum_on_set, doc=r"""on : SoSFBool""")

    def write(self, action):
        r"""write(SoPendulum self, SoWriteAction action)"""
        return _coin.SoPendulum_write(self, action)

# Register SoPendulum in _coin:
_coin.SoPendulum_swigregister(SoPendulum)
class SoRotor(SoRotation):
    r"""Proxy of C++ SoRotor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoRotor self) -> SoType"""
        return _coin.SoRotor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoRotor_initClass()

    def __init__(self):
        r"""__init__(SoRotor self) -> SoRotor"""
        _coin.SoRotor_swiginit(self, _coin.new_SoRotor())
    speed = property(_coin.SoRotor_speed_get, _coin.SoRotor_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoRotor_on_get, _coin.SoRotor_on_set, doc=r"""on : SoSFBool""")

# Register SoRotor in _coin:
_coin.SoRotor_swigregister(SoRotor)
class SoResetTransform(SoTransformation):
    r"""Proxy of C++ SoResetTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoResetTransform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoResetTransform self) -> SoType"""
        return _coin.SoResetTransform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoResetTransform_initClass()

    def __init__(self):
        r"""__init__(SoResetTransform self) -> SoResetTransform"""
        _coin.SoResetTransform_swiginit(self, _coin.new_SoResetTransform())
    TRANSFORM = _coin.SoResetTransform_TRANSFORM
    
    BBOX = _coin.SoResetTransform_BBOX
    
    whatToReset = property(_coin.SoResetTransform_whatToReset_get, _coin.SoResetTransform_whatToReset_set, doc=r"""whatToReset : SoSFBitMask""")

    def doAction(self, action):
        r"""doAction(SoResetTransform self, SoAction action)"""
        return _coin.SoResetTransform_doAction(self, action)

    def callback(self, action):
        r"""callback(SoResetTransform self, SoCallbackAction action)"""
        return _coin.SoResetTransform_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoResetTransform self, SoGLRenderAction action)"""
        return _coin.SoResetTransform_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoResetTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoResetTransform_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoResetTransform self, SoGetMatrixAction action)"""
        return _coin.SoResetTransform_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoResetTransform self, SoPickAction action)"""
        return _coin.SoResetTransform_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoResetTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoResetTransform_getPrimitiveCount(self, action)

# Register SoResetTransform in _coin:
_coin.SoResetTransform_swigregister(SoResetTransform)
class SoRotationXYZ(SoTransformation):
    r"""Proxy of C++ SoRotationXYZ class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoRotationXYZ_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoRotationXYZ self) -> SoType"""
        return _coin.SoRotationXYZ_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoRotationXYZ_initClass()

    def __init__(self):
        r"""__init__(SoRotationXYZ self) -> SoRotationXYZ"""
        _coin.SoRotationXYZ_swiginit(self, _coin.new_SoRotationXYZ())
    X = _coin.SoRotationXYZ_X
    
    Y = _coin.SoRotationXYZ_Y
    
    Z = _coin.SoRotationXYZ_Z
    
    axis = property(_coin.SoRotationXYZ_axis_get, _coin.SoRotationXYZ_axis_set, doc=r"""axis : SoSFEnum""")
    angle = property(_coin.SoRotationXYZ_angle_get, _coin.SoRotationXYZ_angle_set, doc=r"""angle : SoSFFloat""")

    def getRotation(self):
        r"""getRotation(SoRotationXYZ self) -> SbRotation"""
        return _coin.SoRotationXYZ_getRotation(self)

    def doAction(self, action):
        r"""doAction(SoRotationXYZ self, SoAction action)"""
        return _coin.SoRotationXYZ_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoRotationXYZ self, SoGLRenderAction action)"""
        return _coin.SoRotationXYZ_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoRotationXYZ self, SoCallbackAction action)"""
        return _coin.SoRotationXYZ_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoRotationXYZ self, SoGetBoundingBoxAction action)"""
        return _coin.SoRotationXYZ_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoRotationXYZ self, SoGetMatrixAction action)"""
        return _coin.SoRotationXYZ_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoRotationXYZ self, SoPickAction action)"""
        return _coin.SoRotationXYZ_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoRotationXYZ self, SoGetPrimitiveCountAction action)"""
        return _coin.SoRotationXYZ_getPrimitiveCount(self, action)

# Register SoRotationXYZ in _coin:
_coin.SoRotationXYZ_swigregister(SoRotationXYZ)
class SoTranslation(SoTransformation):
    r"""Proxy of C++ SoTranslation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTranslation_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTranslation self) -> SoType"""
        return _coin.SoTranslation_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTranslation_initClass()

    def __init__(self):
        r"""__init__(SoTranslation self) -> SoTranslation"""
        _coin.SoTranslation_swiginit(self, _coin.new_SoTranslation())
    translation = property(_coin.SoTranslation_translation_get, _coin.SoTranslation_translation_set, doc=r"""translation : SoSFVec3f""")

    def doAction(self, action):
        r"""doAction(SoTranslation self, SoAction action)"""
        return _coin.SoTranslation_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTranslation self, SoCallbackAction action)"""
        return _coin.SoTranslation_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTranslation self, SoGLRenderAction action)"""
        return _coin.SoTranslation_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoTranslation self, SoGetBoundingBoxAction action)"""
        return _coin.SoTranslation_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoTranslation self, SoGetMatrixAction action)"""
        return _coin.SoTranslation_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoTranslation self, SoPickAction action)"""
        return _coin.SoTranslation_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoTranslation self, SoGetPrimitiveCountAction action)"""
        return _coin.SoTranslation_getPrimitiveCount(self, action)

# Register SoTranslation in _coin:
_coin.SoTranslation_swigregister(SoTranslation)
class SoShuttle(SoTranslation):
    r"""Proxy of C++ SoShuttle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShuttle_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShuttle self) -> SoType"""
        return _coin.SoShuttle_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShuttle_initClass()

    def __init__(self):
        r"""__init__(SoShuttle self) -> SoShuttle"""
        _coin.SoShuttle_swiginit(self, _coin.new_SoShuttle())
    translation0 = property(_coin.SoShuttle_translation0_get, _coin.SoShuttle_translation0_set, doc=r"""translation0 : SoSFVec3f""")
    translation1 = property(_coin.SoShuttle_translation1_get, _coin.SoShuttle_translation1_set, doc=r"""translation1 : SoSFVec3f""")
    speed = property(_coin.SoShuttle_speed_get, _coin.SoShuttle_speed_set, doc=r"""speed : SoSFFloat""")
    on = property(_coin.SoShuttle_on_get, _coin.SoShuttle_on_set, doc=r"""on : SoSFBool""")

    def write(self, action):
        r"""write(SoShuttle self, SoWriteAction action)"""
        return _coin.SoShuttle_write(self, action)

# Register SoShuttle in _coin:
_coin.SoShuttle_swigregister(SoShuttle)
class SoSurroundScale(SoTransformation):
    r"""Proxy of C++ SoSurroundScale class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSurroundScale_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSurroundScale self) -> SoType"""
        return _coin.SoSurroundScale_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSurroundScale_initClass()

    def __init__(self):
        r"""__init__(SoSurroundScale self) -> SoSurroundScale"""
        _coin.SoSurroundScale_swiginit(self, _coin.new_SoSurroundScale())
    numNodesUpToContainer = property(_coin.SoSurroundScale_numNodesUpToContainer_get, _coin.SoSurroundScale_numNodesUpToContainer_set, doc=r"""numNodesUpToContainer : SoSFInt32""")
    numNodesUpToReset = property(_coin.SoSurroundScale_numNodesUpToReset_get, _coin.SoSurroundScale_numNodesUpToReset_set, doc=r"""numNodesUpToReset : SoSFInt32""")

    def invalidate(self):
        r"""invalidate(SoSurroundScale self)"""
        return _coin.SoSurroundScale_invalidate(self)

    def doAction(self, action):
        r"""doAction(SoSurroundScale self, SoAction action)"""
        return _coin.SoSurroundScale_doAction(self, action)

    def setDoingTranslations(self, val):
        r"""setDoingTranslations(SoSurroundScale self, SbBool const val)"""
        return _coin.SoSurroundScale_setDoingTranslations(self, val)

    def isDoingTranslations(self):
        r"""isDoingTranslations(SoSurroundScale self) -> SbBool"""
        return _coin.SoSurroundScale_isDoingTranslations(self)

# Register SoSurroundScale in _coin:
_coin.SoSurroundScale_swigregister(SoSurroundScale)
class SoNurbsProfile(SoProfile):
    r"""Proxy of C++ SoNurbsProfile class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNurbsProfile_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoNurbsProfile self) -> SoType"""
        return _coin.SoNurbsProfile_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNurbsProfile_initClass()

    def __init__(self):
        r"""__init__(SoNurbsProfile self) -> SoNurbsProfile"""
        _coin.SoNurbsProfile_swiginit(self, _coin.new_SoNurbsProfile())
    knotVector = property(_coin.SoNurbsProfile_knotVector_get, _coin.SoNurbsProfile_knotVector_set, doc=r"""knotVector : SoMFFloat""")

    def getTrimCurve(self, state, numpoints, points, floatspervec, numknots, knotvector):
        r"""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):
        r"""getVertices(SoNurbsProfile self, SoState state, int32_t & numvertices, SbVec2f *& vertices)"""
        return _coin.SoNurbsProfile_getVertices(self, state, numvertices, vertices)

# Register SoNurbsProfile in _coin:
_coin.SoNurbsProfile_swigregister(SoNurbsProfile)
class SoVertexAttribute(SoNode):
    r"""Proxy of C++ SoVertexAttribute class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoVertexAttribute self) -> SoVertexAttribute"""
        _coin.SoVertexAttribute_swiginit(self, _coin.new_SoVertexAttribute())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVertexAttribute_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexAttribute_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVertexAttribute self) -> SoType"""
        return _coin.SoVertexAttribute_getTypeId(self)
    name = property(_coin.SoVertexAttribute_name_get, _coin.SoVertexAttribute_name_set, doc=r"""name : SoSFName""")
    typeName = property(_coin.SoVertexAttribute_typeName_get, _coin.SoVertexAttribute_typeName_set, doc=r"""typeName : SoSFName""")

    def getValuesField(self):
        r"""getValuesField(SoVertexAttribute self) -> SoMField"""
        return _coin.SoVertexAttribute_getValuesField(self)

    def doAction(self, action):
        r"""doAction(SoVertexAttribute self, SoAction action)"""
        return _coin.SoVertexAttribute_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVertexAttribute self, SoGLRenderAction action)"""
        return _coin.SoVertexAttribute_GLRender(self, action)

    def write(self, action):
        r"""write(SoVertexAttribute self, SoWriteAction action)"""
        return _coin.SoVertexAttribute_write(self, action)

    def copyContents(self, srcFrom, copyconnections):
        r"""copyContents(SoVertexAttribute self, SoFieldContainer srcFrom, SbBool copyconnections)"""
        return _coin.SoVertexAttribute_copyContents(self, srcFrom, copyconnections)

    def notify(self, l):
        r"""notify(SoVertexAttribute self, SoNotList l)"""
        return _coin.SoVertexAttribute_notify(self, l)

# Register SoVertexAttribute in _coin:
_coin.SoVertexAttribute_swigregister(SoVertexAttribute)
class SoVertexAttributeBinding(SoNode):
    r"""Proxy of C++ SoVertexAttributeBinding class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexAttributeBinding_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVertexAttributeBinding self) -> SoType"""
        return _coin.SoVertexAttributeBinding_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVertexAttributeBinding_initClass()

    def __init__(self):
        r"""__init__(SoVertexAttributeBinding self) -> SoVertexAttributeBinding"""
        _coin.SoVertexAttributeBinding_swiginit(self, _coin.new_SoVertexAttributeBinding())
    OVERALL = _coin.SoVertexAttributeBinding_OVERALL
    
    PER_VERTEX = _coin.SoVertexAttributeBinding_PER_VERTEX
    
    PER_VERTEX_INDEXED = _coin.SoVertexAttributeBinding_PER_VERTEX_INDEXED
    
    DEFAULT = _coin.SoVertexAttributeBinding_DEFAULT
    
    value = property(_coin.SoVertexAttributeBinding_value_get, _coin.SoVertexAttributeBinding_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoVertexAttributeBinding self, SoAction action)"""
        return _coin.SoVertexAttributeBinding_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVertexAttributeBinding self, SoGLRenderAction action)"""
        return _coin.SoVertexAttributeBinding_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoVertexAttributeBinding self, SoCallbackAction action)"""
        return _coin.SoVertexAttributeBinding_callback(self, action)

    def pick(self, action):
        r"""pick(SoVertexAttributeBinding self, SoPickAction action)"""
        return _coin.SoVertexAttributeBinding_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVertexAttributeBinding self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVertexAttributeBinding_getPrimitiveCount(self, action)

# Register SoVertexAttributeBinding in _coin:
_coin.SoVertexAttributeBinding_swigregister(SoVertexAttributeBinding)
class SoNormal(SoNode):
    r"""Proxy of C++ SoNormal class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoNormal_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoNormal self) -> SoType"""
        return _coin.SoNormal_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoNormal_initClass()

    def __init__(self):
        r"""__init__(SoNormal self) -> SoNormal"""
        _coin.SoNormal_swiginit(self, _coin.new_SoNormal())
    vector = property(_coin.SoNormal_vector_get, _coin.SoNormal_vector_set, doc=r"""vector : SoMFVec3f""")

    def doAction(self, action):
        r"""doAction(SoNormal self, SoAction action)"""
        return _coin.SoNormal_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoNormal self, SoGLRenderAction action)"""
        return _coin.SoNormal_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoNormal self, SoCallbackAction action)"""
        return _coin.SoNormal_callback(self, action)

    def pick(self, action):
        r"""pick(SoNormal self, SoPickAction action)"""
        return _coin.SoNormal_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoNormal self, SoGetPrimitiveCountAction action)"""
        return _coin.SoNormal_getPrimitiveCount(self, action)

# Register SoNormal in _coin:
_coin.SoNormal_swigregister(SoNormal)
class SoPackedColor(SoNode):
    r"""Proxy of C++ SoPackedColor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPackedColor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPackedColor self) -> SoType"""
        return _coin.SoPackedColor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPackedColor_initClass()

    def __init__(self):
        r"""__init__(SoPackedColor self) -> SoPackedColor"""
        _coin.SoPackedColor_swiginit(self, _coin.new_SoPackedColor())
    orderedRGBA = property(_coin.SoPackedColor_orderedRGBA_get, _coin.SoPackedColor_orderedRGBA_set, doc=r"""orderedRGBA : SoMFUInt32""")

    def doAction(self, action):
        r"""doAction(SoPackedColor self, SoAction action)"""
        return _coin.SoPackedColor_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoPackedColor self, SoGLRenderAction action)"""
        return _coin.SoPackedColor_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoPackedColor self, SoCallbackAction action)"""
        return _coin.SoPackedColor_callback(self, action)

    def isTransparent(self):
        r"""isTransparent(SoPackedColor self) -> SbBool"""
        return _coin.SoPackedColor_isTransparent(self)

# Register SoPackedColor in _coin:
_coin.SoPackedColor_swigregister(SoPackedColor)
class SoPolygonOffset(SoNode):
    r"""Proxy of C++ SoPolygonOffset class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoPolygonOffset_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoPolygonOffset self) -> SoType"""
        return _coin.SoPolygonOffset_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoPolygonOffset_initClass()

    def __init__(self):
        r"""__init__(SoPolygonOffset self) -> SoPolygonOffset"""
        _coin.SoPolygonOffset_swiginit(self, _coin.new_SoPolygonOffset())
    FILLED = _coin.SoPolygonOffset_FILLED
    
    LINES = _coin.SoPolygonOffset_LINES
    
    POINTS = _coin.SoPolygonOffset_POINTS
    
    factor = property(_coin.SoPolygonOffset_factor_get, _coin.SoPolygonOffset_factor_set, doc=r"""factor : SoSFFloat""")
    units = property(_coin.SoPolygonOffset_units_get, _coin.SoPolygonOffset_units_set, doc=r"""units : SoSFFloat""")
    styles = property(_coin.SoPolygonOffset_styles_get, _coin.SoPolygonOffset_styles_set, doc=r"""styles : SoSFBitMask""")
    on = property(_coin.SoPolygonOffset_on_get, _coin.SoPolygonOffset_on_set, doc=r"""on : SoSFBool""")

    def doAction(self, action):
        r"""doAction(SoPolygonOffset self, SoAction action)"""
        return _coin.SoPolygonOffset_doAction(self, action)

    def callback(self, action):
        r"""callback(SoPolygonOffset self, SoCallbackAction action)"""
        return _coin.SoPolygonOffset_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoPolygonOffset self, SoGLRenderAction action)"""
        return _coin.SoPolygonOffset_GLRender(self, action)

# Register SoPolygonOffset in _coin:
_coin.SoPolygonOffset_swigregister(SoPolygonOffset)
class SoProfileCoordinate2(SoNode):
    r"""Proxy of C++ SoProfileCoordinate2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinate2_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoProfileCoordinate2 self) -> SoType"""
        return _coin.SoProfileCoordinate2_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoProfileCoordinate2_initClass()

    def __init__(self):
        r"""__init__(SoProfileCoordinate2 self) -> SoProfileCoordinate2"""
        _coin.SoProfileCoordinate2_swiginit(self, _coin.new_SoProfileCoordinate2())
    point = property(_coin.SoProfileCoordinate2_point_get, _coin.SoProfileCoordinate2_point_set, doc=r"""point : SoMFVec2f""")

    def doAction(self, action):
        r"""doAction(SoProfileCoordinate2 self, SoAction action)"""
        return _coin.SoProfileCoordinate2_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoProfileCoordinate2 self, SoGLRenderAction action)"""
        return _coin.SoProfileCoordinate2_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoProfileCoordinate2 self, SoCallbackAction action)"""
        return _coin.SoProfileCoordinate2_callback(self, action)

    def pick(self, action):
        r"""pick(SoProfileCoordinate2 self, SoPickAction action)"""
        return _coin.SoProfileCoordinate2_pick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoProfileCoordinate2 self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfileCoordinate2_getBoundingBox(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoProfileCoordinate2 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfileCoordinate2_getPrimitiveCount(self, action)

# Register SoProfileCoordinate2 in _coin:
_coin.SoProfileCoordinate2_swigregister(SoProfileCoordinate2)
class SoProfileCoordinate3(SoNode):
    r"""Proxy of C++ SoProfileCoordinate3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoProfileCoordinate3_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoProfileCoordinate3 self) -> SoType"""
        return _coin.SoProfileCoordinate3_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoProfileCoordinate3_initClass()

    def __init__(self):
        r"""__init__(SoProfileCoordinate3 self) -> SoProfileCoordinate3"""
        _coin.SoProfileCoordinate3_swiginit(self, _coin.new_SoProfileCoordinate3())
    point = property(_coin.SoProfileCoordinate3_point_get, _coin.SoProfileCoordinate3_point_set, doc=r"""point : SoMFVec3f""")

    def doAction(self, action):
        r"""doAction(SoProfileCoordinate3 self, SoAction action)"""
        return _coin.SoProfileCoordinate3_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoProfileCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoProfileCoordinate3_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoProfileCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoProfileCoordinate3_callback(self, action)

    def pick(self, action):
        r"""pick(SoProfileCoordinate3 self, SoPickAction action)"""
        return _coin.SoProfileCoordinate3_pick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoProfileCoordinate3 self, SoGetBoundingBoxAction action)"""
        return _coin.SoProfileCoordinate3_getBoundingBox(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoProfileCoordinate3 self, SoGetPrimitiveCountAction action)"""
        return _coin.SoProfileCoordinate3_getPrimitiveCount(self, action)

# Register SoProfileCoordinate3 in _coin:
_coin.SoProfileCoordinate3_swigregister(SoProfileCoordinate3)
class SoTexture3(SoTexture):
    r"""Proxy of C++ SoTexture3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture3_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTexture3 self) -> SoType"""
        return _coin.SoTexture3_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTexture3_initClass()

    def __init__(self):
        r"""__init__(SoTexture3 self) -> SoTexture3"""
        _coin.SoTexture3_swiginit(self, _coin.new_SoTexture3())
    MODULATE = _coin.SoTexture3_MODULATE
    
    DECAL = _coin.SoTexture3_DECAL
    
    BLEND = _coin.SoTexture3_BLEND
    
    REPEAT = _coin.SoTexture3_REPEAT
    
    CLAMP = _coin.SoTexture3_CLAMP
    
    filenames = property(_coin.SoTexture3_filenames_get, _coin.SoTexture3_filenames_set, doc=r"""filenames : SoMFString""")
    images = property(_coin.SoTexture3_images_get, _coin.SoTexture3_images_set, doc=r"""images : SoSFImage3""")
    wrapR = property(_coin.SoTexture3_wrapR_get, _coin.SoTexture3_wrapR_set, doc=r"""wrapR : SoSFEnum""")
    wrapS = property(_coin.SoTexture3_wrapS_get, _coin.SoTexture3_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoTexture3_wrapT_get, _coin.SoTexture3_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    model = property(_coin.SoTexture3_model_get, _coin.SoTexture3_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoTexture3_blendColor_get, _coin.SoTexture3_blendColor_set, doc=r"""blendColor : SoSFColor""")
    enableCompressedTexture = property(_coin.SoTexture3_enableCompressedTexture_get, _coin.SoTexture3_enableCompressedTexture_set, doc=r"""enableCompressedTexture : SoSFBool""")

    def doAction(self, action):
        r"""doAction(SoTexture3 self, SoAction action)"""
        return _coin.SoTexture3_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTexture3 self, SoGLRenderAction action)"""
        return _coin.SoTexture3_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTexture3 self, SoCallbackAction action)"""
        return _coin.SoTexture3_callback(self, action)

# Register SoTexture3 in _coin:
_coin.SoTexture3_swigregister(SoTexture3)
class SoTexture2Transform(SoNode):
    r"""Proxy of C++ SoTexture2Transform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture2Transform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTexture2Transform self) -> SoType"""
        return _coin.SoTexture2Transform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTexture2Transform_initClass()

    def __init__(self):
        r"""__init__(SoTexture2Transform self) -> SoTexture2Transform"""
        _coin.SoTexture2Transform_swiginit(self, _coin.new_SoTexture2Transform())
    translation = property(_coin.SoTexture2Transform_translation_get, _coin.SoTexture2Transform_translation_set, doc=r"""translation : SoSFVec2f""")
    rotation = property(_coin.SoTexture2Transform_rotation_get, _coin.SoTexture2Transform_rotation_set, doc=r"""rotation : SoSFFloat""")
    scaleFactor = property(_coin.SoTexture2Transform_scaleFactor_get, _coin.SoTexture2Transform_scaleFactor_set, doc=r"""scaleFactor : SoSFVec2f""")
    center = property(_coin.SoTexture2Transform_center_get, _coin.SoTexture2Transform_center_set, doc=r"""center : SoSFVec2f""")

    def doAction(self, action):
        r"""doAction(SoTexture2Transform self, SoAction action)"""
        return _coin.SoTexture2Transform_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTexture2Transform self, SoCallbackAction action)"""
        return _coin.SoTexture2Transform_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTexture2Transform self, SoGLRenderAction action)"""
        return _coin.SoTexture2Transform_GLRender(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoTexture2Transform self, SoGetMatrixAction action)"""
        return _coin.SoTexture2Transform_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoTexture2Transform self, SoPickAction action)"""
        return _coin.SoTexture2Transform_pick(self, action)

# Register SoTexture2Transform in _coin:
_coin.SoTexture2Transform_swigregister(SoTexture2Transform)
class SoTexture3Transform(SoNode):
    r"""Proxy of C++ SoTexture3Transform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTexture3Transform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTexture3Transform self) -> SoType"""
        return _coin.SoTexture3Transform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTexture3Transform_initClass()

    def __init__(self):
        r"""__init__(SoTexture3Transform self) -> SoTexture3Transform"""
        _coin.SoTexture3Transform_swiginit(self, _coin.new_SoTexture3Transform())
    translation = property(_coin.SoTexture3Transform_translation_get, _coin.SoTexture3Transform_translation_set, doc=r"""translation : SoSFVec3f""")
    rotation = property(_coin.SoTexture3Transform_rotation_get, _coin.SoTexture3Transform_rotation_set, doc=r"""rotation : SoSFRotation""")
    scaleFactor = property(_coin.SoTexture3Transform_scaleFactor_get, _coin.SoTexture3Transform_scaleFactor_set, doc=r"""scaleFactor : SoSFVec3f""")
    scaleOrientation = property(_coin.SoTexture3Transform_scaleOrientation_get, _coin.SoTexture3Transform_scaleOrientation_set, doc=r"""scaleOrientation : SoSFRotation""")
    center = property(_coin.SoTexture3Transform_center_get, _coin.SoTexture3Transform_center_set, doc=r"""center : SoSFVec3f""")

    def doAction(self, action):
        r"""doAction(SoTexture3Transform self, SoAction action)"""
        return _coin.SoTexture3Transform_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTexture3Transform self, SoCallbackAction action)"""
        return _coin.SoTexture3Transform_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTexture3Transform self, SoGLRenderAction action)"""
        return _coin.SoTexture3Transform_GLRender(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoTexture3Transform self, SoGetMatrixAction action)"""
        return _coin.SoTexture3Transform_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoTexture3Transform self, SoPickAction action)"""
        return _coin.SoTexture3Transform_pick(self, action)

# Register SoTexture3Transform in _coin:
_coin.SoTexture3Transform_swigregister(SoTexture3Transform)
class SoTextureCoordinate2(SoNode):
    r"""Proxy of C++ SoTextureCoordinate2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinate2_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinate2 self) -> SoType"""
        return _coin.SoTextureCoordinate2_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinate2_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinate2 self) -> SoTextureCoordinate2"""
        _coin.SoTextureCoordinate2_swiginit(self, _coin.new_SoTextureCoordinate2())
    point = property(_coin.SoTextureCoordinate2_point_get, _coin.SoTextureCoordinate2_point_set, doc=r"""point : SoMFVec2f""")

    def doAction(self, action):
        r"""doAction(SoTextureCoordinate2 self, SoAction action)"""
        return _coin.SoTextureCoordinate2_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinate2 self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinate2_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinate2 self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinate2_callback(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinate2 self, SoPickAction action)"""
        return _coin.SoTextureCoordinate2_pick(self, action)

# Register SoTextureCoordinate2 in _coin:
_coin.SoTextureCoordinate2_swigregister(SoTextureCoordinate2)
class SoTextureCoordinate3(SoNode):
    r"""Proxy of C++ SoTextureCoordinate3 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinate3_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinate3 self) -> SoType"""
        return _coin.SoTextureCoordinate3_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinate3_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinate3 self) -> SoTextureCoordinate3"""
        _coin.SoTextureCoordinate3_swiginit(self, _coin.new_SoTextureCoordinate3())
    point = property(_coin.SoTextureCoordinate3_point_get, _coin.SoTextureCoordinate3_point_set, doc=r"""point : SoMFVec3f""")

    def doAction(self, action):
        r"""doAction(SoTextureCoordinate3 self, SoAction action)"""
        return _coin.SoTextureCoordinate3_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinate3 self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinate3_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinate3 self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinate3_callback(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinate3 self, SoPickAction action)"""
        return _coin.SoTextureCoordinate3_pick(self, action)

# Register SoTextureCoordinate3 in _coin:
_coin.SoTextureCoordinate3_swigregister(SoTextureCoordinate3)
class SoTextureCoordinateFunction(SoNode):
    r"""Proxy of C++ SoTextureCoordinateFunction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateFunction_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateFunction self) -> SoType"""
        return _coin.SoTextureCoordinateFunction_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateFunction_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateFunction self) -> SoTextureCoordinateFunction"""
        _coin.SoTextureCoordinateFunction_swiginit(self, _coin.new_SoTextureCoordinateFunction())

# Register SoTextureCoordinateFunction in _coin:
_coin.SoTextureCoordinateFunction_swigregister(SoTextureCoordinateFunction)
class SoTextureCoordinateDefault(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateDefault class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateDefault_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateDefault self) -> SoType"""
        return _coin.SoTextureCoordinateDefault_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateDefault_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateDefault self) -> SoTextureCoordinateDefault"""
        _coin.SoTextureCoordinateDefault_swiginit(self, _coin.new_SoTextureCoordinateDefault())

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateDefault self, SoAction action)"""
        return _coin.SoTextureCoordinateDefault_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateDefault self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateDefault_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateDefault self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateDefault_callback(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateDefault self, SoPickAction action)"""
        return _coin.SoTextureCoordinateDefault_pick(self, action)

# Register SoTextureCoordinateDefault in _coin:
_coin.SoTextureCoordinateDefault_swigregister(SoTextureCoordinateDefault)
class SoTextureCoordinateEnvironment(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateEnvironment class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateEnvironment_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateEnvironment self) -> SoType"""
        return _coin.SoTextureCoordinateEnvironment_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateEnvironment_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateEnvironment self) -> SoTextureCoordinateEnvironment"""
        _coin.SoTextureCoordinateEnvironment_swiginit(self, _coin.new_SoTextureCoordinateEnvironment())

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateEnvironment self, SoAction action)"""
        return _coin.SoTextureCoordinateEnvironment_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateEnvironment self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateEnvironment_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateEnvironment self, SoPickAction action)"""
        return _coin.SoTextureCoordinateEnvironment_pick(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateEnvironment self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateEnvironment_callback(self, action)

# Register SoTextureCoordinateEnvironment in _coin:
_coin.SoTextureCoordinateEnvironment_swigregister(SoTextureCoordinateEnvironment)
class SoTextureCoordinatePlane(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinatePlane class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinatePlane_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinatePlane self) -> SoType"""
        return _coin.SoTextureCoordinatePlane_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinatePlane_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinatePlane self) -> SoTextureCoordinatePlane"""
        _coin.SoTextureCoordinatePlane_swiginit(self, _coin.new_SoTextureCoordinatePlane())
    directionS = property(_coin.SoTextureCoordinatePlane_directionS_get, _coin.SoTextureCoordinatePlane_directionS_set, doc=r"""directionS : SoSFVec3f""")
    directionT = property(_coin.SoTextureCoordinatePlane_directionT_get, _coin.SoTextureCoordinatePlane_directionT_set, doc=r"""directionT : SoSFVec3f""")
    directionR = property(_coin.SoTextureCoordinatePlane_directionR_get, _coin.SoTextureCoordinatePlane_directionR_set, doc=r"""directionR : SoSFVec3f""")

    def doAction(self, action):
        r"""doAction(SoTextureCoordinatePlane self, SoAction action)"""
        return _coin.SoTextureCoordinatePlane_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinatePlane self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinatePlane_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinatePlane self, SoPickAction action)"""
        return _coin.SoTextureCoordinatePlane_pick(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinatePlane self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinatePlane_callback(self, action)

# Register SoTextureCoordinatePlane in _coin:
_coin.SoTextureCoordinatePlane_swigregister(SoTextureCoordinatePlane)
class SoTextureMatrixTransform(SoNode):
    r"""Proxy of C++ SoTextureMatrixTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureMatrixTransform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureMatrixTransform self) -> SoType"""
        return _coin.SoTextureMatrixTransform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureMatrixTransform_initClass()

    def __init__(self):
        r"""__init__(SoTextureMatrixTransform self) -> SoTextureMatrixTransform"""
        _coin.SoTextureMatrixTransform_swiginit(self, _coin.new_SoTextureMatrixTransform())
    matrix = property(_coin.SoTextureMatrixTransform_matrix_get, _coin.SoTextureMatrixTransform_matrix_set, doc=r"""matrix : SoSFMatrix""")

    def doAction(self, action):
        r"""doAction(SoTextureMatrixTransform self, SoAction action)"""
        return _coin.SoTextureMatrixTransform_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTextureMatrixTransform self, SoCallbackAction action)"""
        return _coin.SoTextureMatrixTransform_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureMatrixTransform self, SoGLRenderAction action)"""
        return _coin.SoTextureMatrixTransform_GLRender(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoTextureMatrixTransform self, SoGetMatrixAction action)"""
        return _coin.SoTextureMatrixTransform_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoTextureMatrixTransform self, SoPickAction action)"""
        return _coin.SoTextureMatrixTransform_pick(self, action)

# Register SoTextureMatrixTransform in _coin:
_coin.SoTextureMatrixTransform_swigregister(SoTextureMatrixTransform)
class SoWWWInline(SoNode):
    r"""Proxy of C++ SoWWWInline class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoWWWInline_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoWWWInline self) -> SoType"""
        return _coin.SoWWWInline_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoWWWInline_initClass()

    def __init__(self):
        r"""__init__(SoWWWInline self) -> SoWWWInline"""
        _coin.SoWWWInline_swiginit(self, _coin.new_SoWWWInline())
    name = property(_coin.SoWWWInline_name_get, _coin.SoWWWInline_name_set, doc=r"""name : SoSFString""")
    bboxCenter = property(_coin.SoWWWInline_bboxCenter_get, _coin.SoWWWInline_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoWWWInline_bboxSize_get, _coin.SoWWWInline_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")
    alternateRep = property(_coin.SoWWWInline_alternateRep_get, _coin.SoWWWInline_alternateRep_set, doc=r"""alternateRep : SoSFNode""")
    NEVER = _coin.SoWWWInline_NEVER
    
    UNTIL_LOADED = _coin.SoWWWInline_UNTIL_LOADED
    
    ALWAYS = _coin.SoWWWInline_ALWAYS
    

    def setFullURLName(self, url):
        r"""setFullURLName(SoWWWInline self, SbString url)"""
        return _coin.SoWWWInline_setFullURLName(self, url)

    def getFullURLName(self):
        r"""getFullURLName(SoWWWInline self) -> SbString"""
        return _coin.SoWWWInline_getFullURLName(self)

    def copyChildren(self):
        r"""copyChildren(SoWWWInline self) -> SoGroup"""
        return _coin.SoWWWInline_copyChildren(self)

    def requestURLData(self):
        r"""requestURLData(SoWWWInline self)"""
        return _coin.SoWWWInline_requestURLData(self)

    def isURLDataRequested(self):
        r"""isURLDataRequested(SoWWWInline self) -> SbBool"""
        return _coin.SoWWWInline_isURLDataRequested(self)

    def isURLDataHere(self):
        r"""isURLDataHere(SoWWWInline self) -> SbBool"""
        return _coin.SoWWWInline_isURLDataHere(self)

    def cancelURLDataRequest(self):
        r"""cancelURLDataRequest(SoWWWInline self)"""
        return _coin.SoWWWInline_cancelURLDataRequest(self)

    def setChildData(self, urldata):
        r"""setChildData(SoWWWInline self, SoNode urldata)"""
        return _coin.SoWWWInline_setChildData(self, urldata)

    def getChildData(self):
        r"""getChildData(SoWWWInline self) -> SoNode"""
        return _coin.SoWWWInline_getChildData(self)

    def getChildren(self):
        r"""getChildren(SoWWWInline self) -> SoChildList"""
        return _coin.SoWWWInline_getChildren(self)

    @staticmethod
    def setFetchURLCallBack(f, userdata):
        r"""setFetchURLCallBack(SoWWWInlineFetchURLCB * f, void * userdata)"""
        return _coin.SoWWWInline_setFetchURLCallBack(f, userdata)

    @staticmethod
    def setBoundingBoxVisibility(b):
        r"""setBoundingBoxVisibility(SoWWWInline::BboxVisibility b)"""
        return _coin.SoWWWInline_setBoundingBoxVisibility(b)

    @staticmethod
    def getBoundingBoxVisibility():
        r"""getBoundingBoxVisibility() -> SoWWWInline::BboxVisibility"""
        return _coin.SoWWWInline_getBoundingBoxVisibility()

    @staticmethod
    def setBoundingBoxColor(c):
        r"""setBoundingBoxColor(SbColor c)"""
        return _coin.SoWWWInline_setBoundingBoxColor(c)

    @staticmethod
    def getBoundingBoxColor():
        r"""getBoundingBoxColor() -> SbColor"""
        return _coin.SoWWWInline_getBoundingBoxColor()

    @staticmethod
    def setReadAsSoFile(onoff):
        r"""setReadAsSoFile(SbBool onoff)"""
        return _coin.SoWWWInline_setReadAsSoFile(onoff)

    @staticmethod
    def getReadAsSoFile():
        r"""getReadAsSoFile() -> SbBool"""
        return _coin.SoWWWInline_getReadAsSoFile()

    def doAction(self, action):
        r"""doAction(SoWWWInline self, SoAction action)"""
        return _coin.SoWWWInline_doAction(self, action)

    def doActionOnKidsOrBox(self, action):
        r"""doActionOnKidsOrBox(SoWWWInline self, SoAction action)"""
        return _coin.SoWWWInline_doActionOnKidsOrBox(self, action)

    def callback(self, action):
        r"""callback(SoWWWInline self, SoCallbackAction action)"""
        return _coin.SoWWWInline_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoWWWInline self, SoGLRenderAction action)"""
        return _coin.SoWWWInline_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoWWWInline self, SoGetBoundingBoxAction action)"""
        return _coin.SoWWWInline_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoWWWInline self, SoGetMatrixAction action)"""
        return _coin.SoWWWInline_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoWWWInline self, SoHandleEventAction action)"""
        return _coin.SoWWWInline_handleEvent(self, action)

    def search(self, action):
        r"""search(SoWWWInline self, SoSearchAction action)"""
        return _coin.SoWWWInline_search(self, action)

    def pick(self, action):
        r"""pick(SoWWWInline self, SoPickAction action)"""
        return _coin.SoWWWInline_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoWWWInline self, SoGetPrimitiveCountAction action)"""
        return _coin.SoWWWInline_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoWWWInline self, SoAudioRenderAction action)"""
        return _coin.SoWWWInline_audioRender(self, action)

# Register SoWWWInline in _coin:
_coin.SoWWWInline_swigregister(SoWWWInline)
class SoTransparencyType(SoNode):
    r"""Proxy of C++ SoTransparencyType class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTransparencyType_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTransparencyType self) -> SoType"""
        return _coin.SoTransparencyType_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTransparencyType_initClass()

    def __init__(self):
        r"""__init__(SoTransparencyType self) -> SoTransparencyType"""
        _coin.SoTransparencyType_swiginit(self, _coin.new_SoTransparencyType())
    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 = property(_coin.SoTransparencyType_value_get, _coin.SoTransparencyType_value_set, doc=r"""value : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoTransparencyType self, SoAction action)"""
        return _coin.SoTransparencyType_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTransparencyType self, SoGLRenderAction action)"""
        return _coin.SoTransparencyType_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTransparencyType self, SoCallbackAction action)"""
        return _coin.SoTransparencyType_callback(self, action)

# Register SoTransparencyType in _coin:
_coin.SoTransparencyType_swigregister(SoTransparencyType)
class SoTextureCoordinateCube(SoNode):
    r"""Proxy of C++ SoTextureCoordinateCube class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateCube_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateCube self) -> SoType"""
        return _coin.SoTextureCoordinateCube_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateCube_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateCube self) -> SoTextureCoordinateCube"""
        _coin.SoTextureCoordinateCube_swiginit(self, _coin.new_SoTextureCoordinateCube())

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateCube self, SoAction action)"""
        return _coin.SoTextureCoordinateCube_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateCube self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateCube_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateCube self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateCube_callback(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateCube self, SoPickAction action)"""
        return _coin.SoTextureCoordinateCube_pick(self, action)

# Register SoTextureCoordinateCube in _coin:
_coin.SoTextureCoordinateCube_swigregister(SoTextureCoordinateCube)
class SoTextureCoordinateSphere(SoNode):
    r"""Proxy of C++ SoTextureCoordinateSphere class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateSphere_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateSphere self) -> SoType"""
        return _coin.SoTextureCoordinateSphere_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateSphere_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateSphere self) -> SoTextureCoordinateSphere"""
        _coin.SoTextureCoordinateSphere_swiginit(self, _coin.new_SoTextureCoordinateSphere())

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateSphere self, SoAction action)"""
        return _coin.SoTextureCoordinateSphere_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateSphere self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateSphere_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateSphere self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateSphere_callback(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateSphere self, SoPickAction action)"""
        return _coin.SoTextureCoordinateSphere_pick(self, action)

# Register SoTextureCoordinateSphere in _coin:
_coin.SoTextureCoordinateSphere_swigregister(SoTextureCoordinateSphere)
class SoTextureCoordinateCylinder(SoNode):
    r"""Proxy of C++ SoTextureCoordinateCylinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateCylinder_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateCylinder self) -> SoType"""
        return _coin.SoTextureCoordinateCylinder_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateCylinder_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateCylinder self) -> SoTextureCoordinateCylinder"""
        _coin.SoTextureCoordinateCylinder_swiginit(self, _coin.new_SoTextureCoordinateCylinder())

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateCylinder self, SoAction action)"""
        return _coin.SoTextureCoordinateCylinder_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateCylinder self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateCylinder_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateCylinder self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateCylinder_callback(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateCylinder self, SoPickAction action)"""
        return _coin.SoTextureCoordinateCylinder_pick(self, action)

# Register SoTextureCoordinateCylinder in _coin:
_coin.SoTextureCoordinateCylinder_swigregister(SoTextureCoordinateCylinder)
class SoTextureCubeMap(SoTexture):
    r"""Proxy of C++ SoTextureCubeMap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCubeMap_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCubeMap self) -> SoType"""
        return _coin.SoTextureCubeMap_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCubeMap_initClass()

    def __init__(self):
        r"""__init__(SoTextureCubeMap self) -> SoTextureCubeMap"""
        _coin.SoTextureCubeMap_swiginit(self, _coin.new_SoTextureCubeMap())
    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 = property(_coin.SoTextureCubeMap_filenames_get, _coin.SoTextureCubeMap_filenames_set, doc=r"""filenames : SoMFString""")
    imagePosX = property(_coin.SoTextureCubeMap_imagePosX_get, _coin.SoTextureCubeMap_imagePosX_set, doc=r"""imagePosX : SoSFImage""")
    imageNegX = property(_coin.SoTextureCubeMap_imageNegX_get, _coin.SoTextureCubeMap_imageNegX_set, doc=r"""imageNegX : SoSFImage""")
    imagePosY = property(_coin.SoTextureCubeMap_imagePosY_get, _coin.SoTextureCubeMap_imagePosY_set, doc=r"""imagePosY : SoSFImage""")
    imageNegY = property(_coin.SoTextureCubeMap_imageNegY_get, _coin.SoTextureCubeMap_imageNegY_set, doc=r"""imageNegY : SoSFImage""")
    imagePosZ = property(_coin.SoTextureCubeMap_imagePosZ_get, _coin.SoTextureCubeMap_imagePosZ_set, doc=r"""imagePosZ : SoSFImage""")
    imageNegZ = property(_coin.SoTextureCubeMap_imageNegZ_get, _coin.SoTextureCubeMap_imageNegZ_set, doc=r"""imageNegZ : SoSFImage""")
    wrapS = property(_coin.SoTextureCubeMap_wrapS_get, _coin.SoTextureCubeMap_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoTextureCubeMap_wrapT_get, _coin.SoTextureCubeMap_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    model = property(_coin.SoTextureCubeMap_model_get, _coin.SoTextureCubeMap_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoTextureCubeMap_blendColor_get, _coin.SoTextureCubeMap_blendColor_set, doc=r"""blendColor : SoSFColor""")

    def doAction(self, action):
        r"""doAction(SoTextureCubeMap self, SoAction action)"""
        return _coin.SoTextureCubeMap_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCubeMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCubeMap_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoTextureCubeMap self, SoCallbackAction action)"""
        return _coin.SoTextureCubeMap_callback(self, action)

    def rayPick(self, action):
        r"""rayPick(SoTextureCubeMap self, SoRayPickAction action)"""
        return _coin.SoTextureCubeMap_rayPick(self, action)

    @staticmethod
    def readImage(fname, w, h, nc, bytes):
        r"""readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
        return _coin.SoTextureCubeMap_readImage(fname, w, h, nc, bytes)

# Register SoTextureCubeMap in _coin:
_coin.SoTextureCubeMap_swigregister(SoTextureCubeMap)
class SoShaderObject(SoNode):
    r"""Proxy of C++ SoShaderObject class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderObject_getClassTypeId()

    def getTypeId(self):
        r"""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 = property(_coin.SoShaderObject_isActive_get, _coin.SoShaderObject_isActive_set, doc=r"""isActive : SoSFBool""")
    sourceType = property(_coin.SoShaderObject_sourceType_get, _coin.SoShaderObject_sourceType_set, doc=r"""sourceType : SoSFEnum""")
    sourceProgram = property(_coin.SoShaderObject_sourceProgram_get, _coin.SoShaderObject_sourceProgram_set, doc=r"""sourceProgram : SoSFString""")
    parameter = property(_coin.SoShaderObject_parameter_get, _coin.SoShaderObject_parameter_set, doc=r"""parameter : SoMFNode""")

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderObject_initClass()

    def GLRender(self, action):
        r"""GLRender(SoShaderObject self, SoGLRenderAction action)"""
        return _coin.SoShaderObject_GLRender(self, action)

    def search(self, action):
        r"""search(SoShaderObject self, SoSearchAction action)"""
        return _coin.SoShaderObject_search(self, action)

    def updateParameters(self, state):
        r"""updateParameters(SoShaderObject self, SoState state)"""
        return _coin.SoShaderObject_updateParameters(self, state)

    def getSourceType(self):
        r"""getSourceType(SoShaderObject self) -> SoShaderObject::SourceType"""
        return _coin.SoShaderObject_getSourceType(self)

    def getSourceProgram(self):
        r"""getSourceProgram(SoShaderObject self) -> SbString"""
        return _coin.SoShaderObject_getSourceProgram(self)

# Register SoShaderObject in _coin:
_coin.SoShaderObject_swigregister(SoShaderObject)
class SoShaderParameter(SoNode):
    r"""Proxy of C++ SoShaderParameter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter self) -> SoType"""
        return _coin.SoShaderParameter_getTypeId(self)
    name = property(_coin.SoShaderParameter_name_get, _coin.SoShaderParameter_name_set, doc=r"""name : SoSFString""")
    identifier = property(_coin.SoShaderParameter_identifier_get, _coin.SoShaderParameter_identifier_set, doc=r"""identifier : SoSFInt32""")

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter_initClass()

# Register SoShaderParameter in _coin:
_coin.SoShaderParameter_swigregister(SoShaderParameter)
class SoUniformShaderParameter(SoShaderParameter):
    r"""Proxy of C++ SoUniformShaderParameter class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoUniformShaderParameter_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoUniformShaderParameter self) -> SoType"""
        return _coin.SoUniformShaderParameter_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoUniformShaderParameter_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoUniformShaderParameter self, SoGLShaderObject * shaderObject)"""
        return _coin.SoUniformShaderParameter_updateParameter(self, shaderObject)

# Register SoUniformShaderParameter in _coin:
_coin.SoUniformShaderParameter_swigregister(SoUniformShaderParameter)
class SoShaderParameter1f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter1f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter1f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter1f self) -> SoType"""
        return _coin.SoShaderParameter1f_getTypeId(self)
    value = property(_coin.SoShaderParameter1f_value_get, _coin.SoShaderParameter1f_value_set, doc=r"""value : SoSFFloat""")

    def __init__(self):
        r"""__init__(SoShaderParameter1f self) -> SoShaderParameter1f"""
        _coin.SoShaderParameter1f_swiginit(self, _coin.new_SoShaderParameter1f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter1f_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameter1f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter1f_updateParameter(self, shaderObject)

# Register SoShaderParameter1f in _coin:
_coin.SoShaderParameter1f_swigregister(SoShaderParameter1f)
class SoShaderParameter1i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter1i class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter1i_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter1i self) -> SoType"""
        return _coin.SoShaderParameter1i_getTypeId(self)
    value = property(_coin.SoShaderParameter1i_value_get, _coin.SoShaderParameter1i_value_set, doc=r"""value : SoSFInt32""")

    def __init__(self):
        r"""__init__(SoShaderParameter1i self) -> SoShaderParameter1i"""
        _coin.SoShaderParameter1i_swiginit(self, _coin.new_SoShaderParameter1i())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter1i_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameter1i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter1i_updateParameter(self, shaderObject)

# Register SoShaderParameter1i in _coin:
_coin.SoShaderParameter1i_swigregister(SoShaderParameter1i)
class SoShaderParameter2f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter2f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter2f self) -> SoType"""
        return _coin.SoShaderParameter2f_getTypeId(self)
    value = property(_coin.SoShaderParameter2f_value_get, _coin.SoShaderParameter2f_value_set, doc=r"""value : SoSFVec2f""")

    def __init__(self):
        r"""__init__(SoShaderParameter2f self) -> SoShaderParameter2f"""
        _coin.SoShaderParameter2f_swiginit(self, _coin.new_SoShaderParameter2f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter2f_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameter2f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter2f_updateParameter(self, shaderObject)

# Register SoShaderParameter2f in _coin:
_coin.SoShaderParameter2f_swigregister(SoShaderParameter2f)
class SoShaderParameter2i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter2i class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter2i_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter2i self) -> SoType"""
        return _coin.SoShaderParameter2i_getTypeId(self)
    value = property(_coin.SoShaderParameter2i_value_get, _coin.SoShaderParameter2i_value_set, doc=r"""value : SoSFVec2i32""")

    def __init__(self):
        r"""__init__(SoShaderParameter2i self) -> SoShaderParameter2i"""
        _coin.SoShaderParameter2i_swiginit(self, _coin.new_SoShaderParameter2i())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter2i_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameter2i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter2i_updateParameter(self, shaderObject)

# Register SoShaderParameter2i in _coin:
_coin.SoShaderParameter2i_swigregister(SoShaderParameter2i)
class SoShaderParameter3f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter3f self) -> SoType"""
        return _coin.SoShaderParameter3f_getTypeId(self)
    value = property(_coin.SoShaderParameter3f_value_get, _coin.SoShaderParameter3f_value_set, doc=r"""value : SoSFVec3f""")

    def __init__(self):
        r"""__init__(SoShaderParameter3f self) -> SoShaderParameter3f"""
        _coin.SoShaderParameter3f_swiginit(self, _coin.new_SoShaderParameter3f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter3f_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameter3f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter3f_updateParameter(self, shaderObject)

# Register SoShaderParameter3f in _coin:
_coin.SoShaderParameter3f_swigregister(SoShaderParameter3f)
class SoShaderParameter3i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter3i class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter3i_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter3i self) -> SoType"""
        return _coin.SoShaderParameter3i_getTypeId(self)
    value = property(_coin.SoShaderParameter3i_value_get, _coin.SoShaderParameter3i_value_set, doc=r"""value : SoSFVec3i32""")

    def __init__(self):
        r"""__init__(SoShaderParameter3i self) -> SoShaderParameter3i"""
        _coin.SoShaderParameter3i_swiginit(self, _coin.new_SoShaderParameter3i())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter3i_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameter3i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter3i_updateParameter(self, shaderObject)

# Register SoShaderParameter3i in _coin:
_coin.SoShaderParameter3i_swigregister(SoShaderParameter3i)
class SoShaderParameter4f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter4f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter4f self) -> SoType"""
        return _coin.SoShaderParameter4f_getTypeId(self)
    value = property(_coin.SoShaderParameter4f_value_get, _coin.SoShaderParameter4f_value_set, doc=r"""value : SoSFVec4f""")

    def __init__(self):
        r"""__init__(SoShaderParameter4f self) -> SoShaderParameter4f"""
        _coin.SoShaderParameter4f_swiginit(self, _coin.new_SoShaderParameter4f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter4f_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameter4f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter4f_updateParameter(self, shaderObject)

# Register SoShaderParameter4f in _coin:
_coin.SoShaderParameter4f_swigregister(SoShaderParameter4f)
class SoShaderParameter4i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameter4i class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameter4i_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameter4i self) -> SoType"""
        return _coin.SoShaderParameter4i_getTypeId(self)
    value = property(_coin.SoShaderParameter4i_value_get, _coin.SoShaderParameter4i_value_set, doc=r"""value : SoSFVec4i32""")

    def __init__(self):
        r"""__init__(SoShaderParameter4i self) -> SoShaderParameter4i"""
        _coin.SoShaderParameter4i_swiginit(self, _coin.new_SoShaderParameter4i())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameter4i_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameter4i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameter4i_updateParameter(self, shaderObject)

# Register SoShaderParameter4i in _coin:
_coin.SoShaderParameter4i_swigregister(SoShaderParameter4i)
class SoShaderParameterArray1f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray1f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray1f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterArray1f self) -> SoType"""
        return _coin.SoShaderParameterArray1f_getTypeId(self)
    value = property(_coin.SoShaderParameterArray1f_value_get, _coin.SoShaderParameterArray1f_value_set, doc=r"""value : SoMFFloat""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray1f self) -> SoShaderParameterArray1f"""
        _coin.SoShaderParameterArray1f_swiginit(self, _coin.new_SoShaderParameterArray1f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterArray1f_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterArray1f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray1f_updateParameter(self, shaderObject)

# Register SoShaderParameterArray1f in _coin:
_coin.SoShaderParameterArray1f_swigregister(SoShaderParameterArray1f)
class SoShaderParameterArray1i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray1i class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray1i_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterArray1i self) -> SoType"""
        return _coin.SoShaderParameterArray1i_getTypeId(self)
    value = property(_coin.SoShaderParameterArray1i_value_get, _coin.SoShaderParameterArray1i_value_set, doc=r"""value : SoMFInt32""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray1i self) -> SoShaderParameterArray1i"""
        _coin.SoShaderParameterArray1i_swiginit(self, _coin.new_SoShaderParameterArray1i())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterArray1i_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterArray1i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray1i_updateParameter(self, shaderObject)

# Register SoShaderParameterArray1i in _coin:
_coin.SoShaderParameterArray1i_swigregister(SoShaderParameterArray1i)
class SoShaderParameterArray2f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray2f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray2f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterArray2f self) -> SoType"""
        return _coin.SoShaderParameterArray2f_getTypeId(self)
    value = property(_coin.SoShaderParameterArray2f_value_get, _coin.SoShaderParameterArray2f_value_set, doc=r"""value : SoMFVec2f""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray2f self) -> SoShaderParameterArray2f"""
        _coin.SoShaderParameterArray2f_swiginit(self, _coin.new_SoShaderParameterArray2f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterArray2f_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterArray2f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray2f_updateParameter(self, shaderObject)

# Register SoShaderParameterArray2f in _coin:
_coin.SoShaderParameterArray2f_swigregister(SoShaderParameterArray2f)
class SoShaderParameterArray2i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray2i class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray2i_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterArray2i self) -> SoType"""
        return _coin.SoShaderParameterArray2i_getTypeId(self)
    value = property(_coin.SoShaderParameterArray2i_value_get, _coin.SoShaderParameterArray2i_value_set, doc=r"""value : SoMFVec2i32""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray2i self) -> SoShaderParameterArray2i"""
        _coin.SoShaderParameterArray2i_swiginit(self, _coin.new_SoShaderParameterArray2i())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterArray2i_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterArray2i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray2i_updateParameter(self, shaderObject)

# Register SoShaderParameterArray2i in _coin:
_coin.SoShaderParameterArray2i_swigregister(SoShaderParameterArray2i)
class SoShaderParameterArray3f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray3f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray3f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterArray3f self) -> SoType"""
        return _coin.SoShaderParameterArray3f_getTypeId(self)
    value = property(_coin.SoShaderParameterArray3f_value_get, _coin.SoShaderParameterArray3f_value_set, doc=r"""value : SoMFVec3f""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray3f self) -> SoShaderParameterArray3f"""
        _coin.SoShaderParameterArray3f_swiginit(self, _coin.new_SoShaderParameterArray3f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterArray3f_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterArray3f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray3f_updateParameter(self, shaderObject)

# Register SoShaderParameterArray3f in _coin:
_coin.SoShaderParameterArray3f_swigregister(SoShaderParameterArray3f)
class SoShaderParameterArray3i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray3i class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray3i_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterArray3i self) -> SoType"""
        return _coin.SoShaderParameterArray3i_getTypeId(self)
    value = property(_coin.SoShaderParameterArray3i_value_get, _coin.SoShaderParameterArray3i_value_set, doc=r"""value : SoMFVec3i32""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray3i self) -> SoShaderParameterArray3i"""
        _coin.SoShaderParameterArray3i_swiginit(self, _coin.new_SoShaderParameterArray3i())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterArray3i_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterArray3i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray3i_updateParameter(self, shaderObject)

# Register SoShaderParameterArray3i in _coin:
_coin.SoShaderParameterArray3i_swigregister(SoShaderParameterArray3i)
class SoShaderParameterArray4f(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray4f class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray4f_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterArray4f self) -> SoType"""
        return _coin.SoShaderParameterArray4f_getTypeId(self)
    value = property(_coin.SoShaderParameterArray4f_value_get, _coin.SoShaderParameterArray4f_value_set, doc=r"""value : SoMFVec4f""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray4f self) -> SoShaderParameterArray4f"""
        _coin.SoShaderParameterArray4f_swiginit(self, _coin.new_SoShaderParameterArray4f())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterArray4f_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterArray4f self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray4f_updateParameter(self, shaderObject)

# Register SoShaderParameterArray4f in _coin:
_coin.SoShaderParameterArray4f_swigregister(SoShaderParameterArray4f)
class SoShaderParameterArray4i(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterArray4i class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterArray4i_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterArray4i self) -> SoType"""
        return _coin.SoShaderParameterArray4i_getTypeId(self)
    value = property(_coin.SoShaderParameterArray4i_value_get, _coin.SoShaderParameterArray4i_value_set, doc=r"""value : SoMFVec4i32""")

    def __init__(self):
        r"""__init__(SoShaderParameterArray4i self) -> SoShaderParameterArray4i"""
        _coin.SoShaderParameterArray4i_swiginit(self, _coin.new_SoShaderParameterArray4i())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterArray4i_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterArray4i self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterArray4i_updateParameter(self, shaderObject)

# Register SoShaderParameterArray4i in _coin:
_coin.SoShaderParameterArray4i_swigregister(SoShaderParameterArray4i)
class SoShaderParameterMatrix(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterMatrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterMatrix_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterMatrix self) -> SoType"""
        return _coin.SoShaderParameterMatrix_getTypeId(self)
    value = property(_coin.SoShaderParameterMatrix_value_get, _coin.SoShaderParameterMatrix_value_set, doc=r"""value : SoSFMatrix""")

    def __init__(self):
        r"""__init__(SoShaderParameterMatrix self) -> SoShaderParameterMatrix"""
        _coin.SoShaderParameterMatrix_swiginit(self, _coin.new_SoShaderParameterMatrix())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterMatrix_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterMatrix self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterMatrix_updateParameter(self, shaderObject)

# Register SoShaderParameterMatrix in _coin:
_coin.SoShaderParameterMatrix_swigregister(SoShaderParameterMatrix)
class SoShaderParameterMatrixArray(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderParameterMatrixArray class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderParameterMatrixArray_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderParameterMatrixArray self) -> SoType"""
        return _coin.SoShaderParameterMatrixArray_getTypeId(self)
    value = property(_coin.SoShaderParameterMatrixArray_value_get, _coin.SoShaderParameterMatrixArray_value_set, doc=r"""value : SoMFMatrix""")

    def __init__(self):
        r"""__init__(SoShaderParameterMatrixArray self) -> SoShaderParameterMatrixArray"""
        _coin.SoShaderParameterMatrixArray_swiginit(self, _coin.new_SoShaderParameterMatrixArray())

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderParameterMatrixArray_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderParameterMatrixArray self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderParameterMatrixArray_updateParameter(self, shaderObject)

# Register SoShaderParameterMatrixArray in _coin:
_coin.SoShaderParameterMatrixArray_swigregister(SoShaderParameterMatrixArray)
class SoShaderStateMatrixParameter(SoUniformShaderParameter):
    r"""Proxy of C++ SoShaderStateMatrixParameter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderStateMatrixParameter_getClassTypeId()

    def getTypeId(self):
        r"""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 = property(_coin.SoShaderStateMatrixParameter_matrixType_get, _coin.SoShaderStateMatrixParameter_matrixType_set, doc=r"""matrixType : SoSFEnum""")
    matrixTransform = property(_coin.SoShaderStateMatrixParameter_matrixTransform_get, _coin.SoShaderStateMatrixParameter_matrixTransform_set, doc=r"""matrixTransform : SoSFEnum""")

    def __init__(self):
        r"""__init__(SoShaderStateMatrixParameter self) -> SoShaderStateMatrixParameter"""
        _coin.SoShaderStateMatrixParameter_swiginit(self, _coin.new_SoShaderStateMatrixParameter())
    __swig_destroy__ = _coin.delete_SoShaderStateMatrixParameter

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderStateMatrixParameter_initClass()

    def updateParameter(self, shaderObject):
        r"""updateParameter(SoShaderStateMatrixParameter self, SoGLShaderObject * shaderObject)"""
        return _coin.SoShaderStateMatrixParameter_updateParameter(self, shaderObject)

# Register SoShaderStateMatrixParameter in _coin:
_coin.SoShaderStateMatrixParameter_swigregister(SoShaderStateMatrixParameter)
class SoShaderProgram(SoNode):
    r"""Proxy of C++ SoShaderProgram class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoShaderProgram_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoShaderProgram self) -> SoType"""
        return _coin.SoShaderProgram_getTypeId(self)
    shaderObject = property(_coin.SoShaderProgram_shaderObject_get, _coin.SoShaderProgram_shaderObject_set, doc=r"""shaderObject : SoMFNode""")

    def __init__(self):
        r"""__init__(SoShaderProgram self) -> SoShaderProgram"""
        _coin.SoShaderProgram_swiginit(self, _coin.new_SoShaderProgram())

    def setEnableCallback(self, cb, closure):
        r"""setEnableCallback(SoShaderProgram self, SoShaderProgramEnableCB * cb, void * closure)"""
        return _coin.SoShaderProgram_setEnableCallback(self, cb, closure)

    def GLRender(self, action):
        r"""GLRender(SoShaderProgram self, SoGLRenderAction action)"""
        return _coin.SoShaderProgram_GLRender(self, action)

    def search(self, action):
        r"""search(SoShaderProgram self, SoSearchAction action)"""
        return _coin.SoShaderProgram_search(self, action)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoShaderProgram_initClass()

# Register SoShaderProgram in _coin:
_coin.SoShaderProgram_swigregister(SoShaderProgram)
class SoFragmentShader(SoShaderObject):
    r"""Proxy of C++ SoFragmentShader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoFragmentShader_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoFragmentShader self) -> SoType"""
        return _coin.SoFragmentShader_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoFragmentShader_initClass()

    def __init__(self):
        r"""__init__(SoFragmentShader self) -> SoFragmentShader"""
        _coin.SoFragmentShader_swiginit(self, _coin.new_SoFragmentShader())
    __swig_destroy__ = _coin.delete_SoFragmentShader

    @staticmethod
    def isSupported(sourceType):
        r"""isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
        return _coin.SoFragmentShader_isSupported(sourceType)

# Register SoFragmentShader in _coin:
_coin.SoFragmentShader_swigregister(SoFragmentShader)
class SoVertexShader(SoShaderObject):
    r"""Proxy of C++ SoVertexShader class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVertexShader_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVertexShader self) -> SoType"""
        return _coin.SoVertexShader_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVertexShader_initClass()

    def __init__(self):
        r"""__init__(SoVertexShader self) -> SoVertexShader"""
        _coin.SoVertexShader_swiginit(self, _coin.new_SoVertexShader())
    __swig_destroy__ = _coin.delete_SoVertexShader

    @staticmethod
    def isSupported(sourceType):
        r"""isSupported(SoShaderObject::SourceType sourceType) -> SbBool"""
        return _coin.SoVertexShader_isSupported(sourceType)

# Register SoVertexShader in _coin:
_coin.SoVertexShader_swigregister(SoVertexShader)
class SoTextureCoordinateNormalMap(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateNormalMap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateNormalMap_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateNormalMap self) -> SoType"""
        return _coin.SoTextureCoordinateNormalMap_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateNormalMap_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateNormalMap self) -> SoTextureCoordinateNormalMap"""
        _coin.SoTextureCoordinateNormalMap_swiginit(self, _coin.new_SoTextureCoordinateNormalMap())

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateNormalMap self, SoAction action)"""
        return _coin.SoTextureCoordinateNormalMap_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateNormalMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateNormalMap_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateNormalMap self, SoPickAction action)"""
        return _coin.SoTextureCoordinateNormalMap_pick(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateNormalMap self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateNormalMap_callback(self, action)

# Register SoTextureCoordinateNormalMap in _coin:
_coin.SoTextureCoordinateNormalMap_swigregister(SoTextureCoordinateNormalMap)
class SoTextureCoordinateReflectionMap(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateReflectionMap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateReflectionMap_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateReflectionMap self) -> SoType"""
        return _coin.SoTextureCoordinateReflectionMap_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateReflectionMap_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateReflectionMap self) -> SoTextureCoordinateReflectionMap"""
        _coin.SoTextureCoordinateReflectionMap_swiginit(self, _coin.new_SoTextureCoordinateReflectionMap())

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateReflectionMap self, SoAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateReflectionMap self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateReflectionMap self, SoPickAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_pick(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateReflectionMap self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateReflectionMap_callback(self, action)

# Register SoTextureCoordinateReflectionMap in _coin:
_coin.SoTextureCoordinateReflectionMap_swigregister(SoTextureCoordinateReflectionMap)
class SoTextureCoordinateObject(SoTextureCoordinateFunction):
    r"""Proxy of C++ SoTextureCoordinateObject class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCoordinateObject_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCoordinateObject self) -> SoType"""
        return _coin.SoTextureCoordinateObject_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCoordinateObject_initClass()

    def __init__(self):
        r"""__init__(SoTextureCoordinateObject self) -> SoTextureCoordinateObject"""
        _coin.SoTextureCoordinateObject_swiginit(self, _coin.new_SoTextureCoordinateObject())
    factorS = property(_coin.SoTextureCoordinateObject_factorS_get, _coin.SoTextureCoordinateObject_factorS_set, doc=r"""factorS : SoSFVec4f""")
    factorT = property(_coin.SoTextureCoordinateObject_factorT_get, _coin.SoTextureCoordinateObject_factorT_set, doc=r"""factorT : SoSFVec4f""")
    factorR = property(_coin.SoTextureCoordinateObject_factorR_get, _coin.SoTextureCoordinateObject_factorR_set, doc=r"""factorR : SoSFVec4f""")
    factorQ = property(_coin.SoTextureCoordinateObject_factorQ_get, _coin.SoTextureCoordinateObject_factorQ_set, doc=r"""factorQ : SoSFVec4f""")

    def doAction(self, action):
        r"""doAction(SoTextureCoordinateObject self, SoAction action)"""
        return _coin.SoTextureCoordinateObject_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCoordinateObject self, SoGLRenderAction action)"""
        return _coin.SoTextureCoordinateObject_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTextureCoordinateObject self, SoPickAction action)"""
        return _coin.SoTextureCoordinateObject_pick(self, action)

    def callback(self, action):
        r"""callback(SoTextureCoordinateObject self, SoCallbackAction action)"""
        return _coin.SoTextureCoordinateObject_callback(self, action)

# Register SoTextureCoordinateObject in _coin:
_coin.SoTextureCoordinateObject_swigregister(SoTextureCoordinateObject)
class SoTextureScalePolicy(SoNode):
    r"""Proxy of C++ SoTextureScalePolicy class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureScalePolicy_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureScalePolicy self) -> SoType"""
        return _coin.SoTextureScalePolicy_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureScalePolicy_initClass()

    def __init__(self):
        r"""__init__(SoTextureScalePolicy self) -> SoTextureScalePolicy"""
        _coin.SoTextureScalePolicy_swiginit(self, _coin.new_SoTextureScalePolicy())
    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 = property(_coin.SoTextureScalePolicy_policy_get, _coin.SoTextureScalePolicy_policy_set, doc=r"""policy : SoSFEnum""")
    quality = property(_coin.SoTextureScalePolicy_quality_get, _coin.SoTextureScalePolicy_quality_set, doc=r"""quality : SoSFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoTextureScalePolicy self, SoGLRenderAction action)"""
        return _coin.SoTextureScalePolicy_GLRender(self, action)

# Register SoTextureScalePolicy in _coin:
_coin.SoTextureScalePolicy_swigregister(SoTextureScalePolicy)
class SoTextureUnit(SoNode):
    r"""Proxy of C++ SoTextureUnit class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureUnit_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureUnit self) -> SoType"""
        return _coin.SoTextureUnit_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureUnit_initClass()

    def __init__(self):
        r"""__init__(SoTextureUnit self) -> SoTextureUnit"""
        _coin.SoTextureUnit_swiginit(self, _coin.new_SoTextureUnit())
    BUMP_MAPPING = _coin.SoTextureUnit_BUMP_MAPPING
    
    IMAGE_MAPPING = _coin.SoTextureUnit_IMAGE_MAPPING
    
    unit = property(_coin.SoTextureUnit_unit_get, _coin.SoTextureUnit_unit_set, doc=r"""unit : SoSFInt32""")
    mappingMethod = property(_coin.SoTextureUnit_mappingMethod_get, _coin.SoTextureUnit_mappingMethod_set, doc=r"""mappingMethod : SoSFEnum""")

    def doAction(self, action):
        r"""doAction(SoTextureUnit self, SoAction action)"""
        return _coin.SoTextureUnit_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTextureUnit self, SoCallbackAction action)"""
        return _coin.SoTextureUnit_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureUnit self, SoGLRenderAction action)"""
        return _coin.SoTextureUnit_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTextureUnit self, SoPickAction action)"""
        return _coin.SoTextureUnit_pick(self, action)

    @staticmethod
    def getMaxTextureUnit():
        r"""getMaxTextureUnit() -> uint32_t"""
        return _coin.SoTextureUnit_getMaxTextureUnit()

# Register SoTextureUnit in _coin:
_coin.SoTextureUnit_swigregister(SoTextureUnit)
class SoTextureCombine(SoNode):
    r"""Proxy of C++ SoTextureCombine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoTextureCombine_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoTextureCombine self) -> SoType"""
        return _coin.SoTextureCombine_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoTextureCombine_initClass()

    def __init__(self):
        r"""__init__(SoTextureCombine self) -> SoTextureCombine"""
        _coin.SoTextureCombine_swiginit(self, _coin.new_SoTextureCombine())
    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 = property(_coin.SoTextureCombine_rgbSource_get, _coin.SoTextureCombine_rgbSource_set, doc=r"""rgbSource : SoMFEnum""")
    alphaSource = property(_coin.SoTextureCombine_alphaSource_get, _coin.SoTextureCombine_alphaSource_set, doc=r"""alphaSource : SoMFEnum""")
    rgbOperand = property(_coin.SoTextureCombine_rgbOperand_get, _coin.SoTextureCombine_rgbOperand_set, doc=r"""rgbOperand : SoMFEnum""")
    alphaOperand = property(_coin.SoTextureCombine_alphaOperand_get, _coin.SoTextureCombine_alphaOperand_set, doc=r"""alphaOperand : SoMFEnum""")
    rgbOperation = property(_coin.SoTextureCombine_rgbOperation_get, _coin.SoTextureCombine_rgbOperation_set, doc=r"""rgbOperation : SoSFEnum""")
    alphaOperation = property(_coin.SoTextureCombine_alphaOperation_get, _coin.SoTextureCombine_alphaOperation_set, doc=r"""alphaOperation : SoSFEnum""")
    rgbScale = property(_coin.SoTextureCombine_rgbScale_get, _coin.SoTextureCombine_rgbScale_set, doc=r"""rgbScale : SoSFFloat""")
    alphaScale = property(_coin.SoTextureCombine_alphaScale_get, _coin.SoTextureCombine_alphaScale_set, doc=r"""alphaScale : SoSFFloat""")
    constantColor = property(_coin.SoTextureCombine_constantColor_get, _coin.SoTextureCombine_constantColor_set, doc=r"""constantColor : SoSFVec4f""")

    def doAction(self, action):
        r"""doAction(SoTextureCombine self, SoAction action)"""
        return _coin.SoTextureCombine_doAction(self, action)

    def callback(self, action):
        r"""callback(SoTextureCombine self, SoCallbackAction action)"""
        return _coin.SoTextureCombine_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoTextureCombine self, SoGLRenderAction action)"""
        return _coin.SoTextureCombine_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoTextureCombine self, SoPickAction action)"""
        return _coin.SoTextureCombine_pick(self, action)

# Register SoTextureCombine in _coin:
_coin.SoTextureCombine_swigregister(SoTextureCombine)
class SoSceneTexture2(SoNode):
    r"""Proxy of C++ SoSceneTexture2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSceneTexture2_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSceneTexture2 self) -> SoType"""
        return _coin.SoSceneTexture2_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSceneTexture2_initClass()

    def __init__(self):
        r"""__init__(SoSceneTexture2 self) -> SoSceneTexture2"""
        _coin.SoSceneTexture2_swiginit(self, _coin.new_SoSceneTexture2())
    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 = property(_coin.SoSceneTexture2_wrapS_get, _coin.SoSceneTexture2_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoSceneTexture2_wrapT_get, _coin.SoSceneTexture2_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    model = property(_coin.SoSceneTexture2_model_get, _coin.SoSceneTexture2_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoSceneTexture2_blendColor_get, _coin.SoSceneTexture2_blendColor_set, doc=r"""blendColor : SoSFColor""")
    backgroundColor = property(_coin.SoSceneTexture2_backgroundColor_get, _coin.SoSceneTexture2_backgroundColor_set, doc=r"""backgroundColor : SoSFVec4f""")
    size = property(_coin.SoSceneTexture2_size_get, _coin.SoSceneTexture2_size_set, doc=r"""size : SoSFVec2s""")
    scene = property(_coin.SoSceneTexture2_scene_get, _coin.SoSceneTexture2_scene_set, doc=r"""scene : SoSFNode""")
    sceneTransparencyType = property(_coin.SoSceneTexture2_sceneTransparencyType_get, _coin.SoSceneTexture2_sceneTransparencyType_set, doc=r"""sceneTransparencyType : SoSFNode""")
    transparencyFunction = property(_coin.SoSceneTexture2_transparencyFunction_get, _coin.SoSceneTexture2_transparencyFunction_set, doc=r"""transparencyFunction : SoSFEnum""")
    type = property(_coin.SoSceneTexture2_type_get, _coin.SoSceneTexture2_type_set, doc=r"""type : SoSFEnum""")

    def notify(self, list):
        r"""notify(SoSceneTexture2 self, SoNotList list)"""
        return _coin.SoSceneTexture2_notify(self, list)

    def write(self, action):
        r"""write(SoSceneTexture2 self, SoWriteAction action)"""
        return _coin.SoSceneTexture2_write(self, action)

    def doAction(self, action):
        r"""doAction(SoSceneTexture2 self, SoAction action)"""
        return _coin.SoSceneTexture2_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoSceneTexture2 self, SoGLRenderAction action)"""
        return _coin.SoSceneTexture2_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoSceneTexture2 self, SoCallbackAction action)"""
        return _coin.SoSceneTexture2_callback(self, action)

    def rayPick(self, action):
        r"""rayPick(SoSceneTexture2 self, SoRayPickAction action)"""
        return _coin.SoSceneTexture2_rayPick(self, action)

# Register SoSceneTexture2 in _coin:
_coin.SoSceneTexture2_swigregister(SoSceneTexture2)
class SoSceneTextureCubeMap(SoNode):
    r"""Proxy of C++ SoSceneTextureCubeMap class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoSceneTextureCubeMap_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoSceneTextureCubeMap self) -> SoType"""
        return _coin.SoSceneTextureCubeMap_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoSceneTextureCubeMap_initClass()

    def __init__(self):
        r"""__init__(SoSceneTextureCubeMap self) -> SoSceneTextureCubeMap"""
        _coin.SoSceneTextureCubeMap_swiginit(self, _coin.new_SoSceneTextureCubeMap())
    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 = property(_coin.SoSceneTextureCubeMap_size_get, _coin.SoSceneTextureCubeMap_size_set, doc=r"""size : SoSFVec2s""")
    scene = property(_coin.SoSceneTextureCubeMap_scene_get, _coin.SoSceneTextureCubeMap_scene_set, doc=r"""scene : SoSFNode""")
    wrapS = property(_coin.SoSceneTextureCubeMap_wrapS_get, _coin.SoSceneTextureCubeMap_wrapS_set, doc=r"""wrapS : SoSFEnum""")
    wrapT = property(_coin.SoSceneTextureCubeMap_wrapT_get, _coin.SoSceneTextureCubeMap_wrapT_set, doc=r"""wrapT : SoSFEnum""")
    wrapR = property(_coin.SoSceneTextureCubeMap_wrapR_get, _coin.SoSceneTextureCubeMap_wrapR_set, doc=r"""wrapR : SoSFEnum""")
    model = property(_coin.SoSceneTextureCubeMap_model_get, _coin.SoSceneTextureCubeMap_model_set, doc=r"""model : SoSFEnum""")
    backgroundColor = property(_coin.SoSceneTextureCubeMap_backgroundColor_get, _coin.SoSceneTextureCubeMap_backgroundColor_set, doc=r"""backgroundColor : SoSFColor""")
    transparencyFunction = property(_coin.SoSceneTextureCubeMap_transparencyFunction_get, _coin.SoSceneTextureCubeMap_transparencyFunction_set, doc=r"""transparencyFunction : SoSFEnum""")
    blendColor = property(_coin.SoSceneTextureCubeMap_blendColor_get, _coin.SoSceneTextureCubeMap_blendColor_set, doc=r"""blendColor : SoSFColor""")

    def doAction(self, action):
        r"""doAction(SoSceneTextureCubeMap self, SoAction action)"""
        return _coin.SoSceneTextureCubeMap_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoSceneTextureCubeMap self, SoGLRenderAction action)"""
        return _coin.SoSceneTextureCubeMap_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoSceneTextureCubeMap self, SoCallbackAction action)"""
        return _coin.SoSceneTextureCubeMap_callback(self, action)

    def rayPick(self, action):
        r"""rayPick(SoSceneTextureCubeMap self, SoRayPickAction action)"""
        return _coin.SoSceneTextureCubeMap_rayPick(self, action)

# Register SoSceneTextureCubeMap in _coin:
_coin.SoSceneTextureCubeMap_swigregister(SoSceneTextureCubeMap)
class SoCacheHintElement(SoElement):
    r"""Proxy of C++ SoCacheHintElement class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCacheHintElement_getClassTypeId()

    @staticmethod
    def getClassStackIndex():
        r"""getClassStackIndex() -> int"""
        return _coin.SoCacheHintElement_getClassStackIndex()

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoCacheHintElement_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCacheHintElement_initClass()

    def init(self, state):
        r"""init(SoCacheHintElement self, SoState state)"""
        return _coin.SoCacheHintElement_init(self, state)

    def push(self, state):
        r"""push(SoCacheHintElement self, SoState state)"""
        return _coin.SoCacheHintElement_push(self, state)

    def pop(self, state, prevtopelement):
        r"""pop(SoCacheHintElement self, SoState state, SoElement prevtopelement)"""
        return _coin.SoCacheHintElement_pop(self, state, prevtopelement)

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

    def copyMatchInfo(self):
        r"""copyMatchInfo(SoCacheHintElement self) -> SoElement"""
        return _coin.SoCacheHintElement_copyMatchInfo(self)

    @staticmethod
    def set(state, node, memvalue, gfxvalue):
        r"""set(SoState state, SoNode node, float const memvalue, float const gfxvalue)"""
        return _coin.SoCacheHintElement_set(state, node, memvalue, gfxvalue)

    @staticmethod
    def get(state, memvalue, gfxvalue):
        r"""get(SoState state, float & memvalue, float & gfxvalue)"""
        return _coin.SoCacheHintElement_get(state, memvalue, gfxvalue)

# Register SoCacheHintElement in _coin:
_coin.SoCacheHintElement_swigregister(SoCacheHintElement)
class SoCacheHint(SoNode):
    r"""Proxy of C++ SoCacheHint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoCacheHint_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoCacheHint self) -> SoType"""
        return _coin.SoCacheHint_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoCacheHint_initClass()

    def __init__(self):
        r"""__init__(SoCacheHint self) -> SoCacheHint"""
        _coin.SoCacheHint_swiginit(self, _coin.new_SoCacheHint())
    memValue = property(_coin.SoCacheHint_memValue_get, _coin.SoCacheHint_memValue_set, doc=r"""memValue : SoSFFloat""")
    gfxValue = property(_coin.SoCacheHint_gfxValue_get, _coin.SoCacheHint_gfxValue_set, doc=r"""gfxValue : SoSFFloat""")

    def doAction(self, action):
        r"""doAction(SoCacheHint self, SoAction action)"""
        return _coin.SoCacheHint_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoCacheHint self, SoGLRenderAction action)"""
        return _coin.SoCacheHint_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoCacheHint self, SoCallbackAction action)"""
        return _coin.SoCacheHint_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoCacheHint self, SoGetBoundingBoxAction action)"""
        return _coin.SoCacheHint_getBoundingBox(self, action)

    def pick(self, action):
        r"""pick(SoCacheHint self, SoPickAction action)"""
        return _coin.SoCacheHint_pick(self, action)

# Register SoCacheHint in _coin:
_coin.SoCacheHint_swigregister(SoCacheHint)
class SoDepthBuffer(SoNode):
    r"""Proxy of C++ SoDepthBuffer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoDepthBuffer_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoDepthBuffer self) -> SoType"""
        return _coin.SoDepthBuffer_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoDepthBuffer_initClass()

    def __init__(self):
        r"""__init__(SoDepthBuffer self) -> SoDepthBuffer"""
        _coin.SoDepthBuffer_swiginit(self, _coin.new_SoDepthBuffer())
    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 = property(_coin.SoDepthBuffer_test_get, _coin.SoDepthBuffer_test_set, doc=r"""test : SoSFBool""")
    write = property(_coin.SoDepthBuffer_write_get, _coin.SoDepthBuffer_write_set, doc=r"""write : SoSFBool""")
    function = property(_coin.SoDepthBuffer_function_get, _coin.SoDepthBuffer_function_set, doc=r"""function : SoSFEnum""")
    range = property(_coin.SoDepthBuffer_range_get, _coin.SoDepthBuffer_range_set, doc=r"""range : SoSFVec2f""")

    def GLRender(self, action):
        r"""GLRender(SoDepthBuffer self, SoGLRenderAction action)"""
        return _coin.SoDepthBuffer_GLRender(self, action)

# Register SoDepthBuffer in _coin:
_coin.SoDepthBuffer_swigregister(SoDepthBuffer)
class SbLine(object):
    r"""Proxy of C++ SbLine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbLine self) -> SbLine
        __init__(SbLine self, SbVec3f origin, SbVec3f point) -> SbLine
        """
        _coin.SbLine_swiginit(self, _coin.new_SbLine(*args))

    def setValue(self, origin, point):
        r"""setValue(SbLine self, SbVec3f origin, SbVec3f point)"""
        return _coin.SbLine_setValue(self, origin, point)

    def getClosestPoints(self, line2, ptOnThis, ptOnLine2):
        r"""getClosestPoints(SbLine self, SbLine line2, SbVec3f ptOnThis, SbVec3f ptOnLine2) -> SbBool"""
        return _coin.SbLine_getClosestPoints(self, line2, ptOnThis, ptOnLine2)

    def getClosestPoint(self, point):
        r"""getClosestPoint(SbLine self, SbVec3f point) -> SbVec3f"""
        return _coin.SbLine_getClosestPoint(self, point)

    def getPosition(self):
        r"""getPosition(SbLine self) -> SbVec3f"""
        return _coin.SbLine_getPosition(self)

    def getDirection(self):
        r"""getDirection(SbLine self) -> SbVec3f"""
        return _coin.SbLine_getDirection(self)

    def output(self, file):
        r"""output(SbLine self, FILE * file)"""
        return _coin.SbLine_output(self, file)
    __swig_destroy__ = _coin.delete_SbLine

# Register SbLine in _coin:
_coin.SbLine_swigregister(SbLine)
class SbProjector(object):
    r"""Proxy of C++ SbProjector class."""

    thisown = property(lambda x: 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):
        r"""project(SbProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbProjector_project(self, point)

    def setViewVolume(self, vol):
        r"""setViewVolume(SbProjector self, SbViewVolume vol)"""
        return _coin.SbProjector_setViewVolume(self, vol)

    def getViewVolume(self):
        r"""getViewVolume(SbProjector self) -> SbViewVolume"""
        return _coin.SbProjector_getViewVolume(self)

    def setWorkingSpace(self, space):
        r"""setWorkingSpace(SbProjector self, SbMatrix space)"""
        return _coin.SbProjector_setWorkingSpace(self, space)

    def getWorkingSpace(self):
        r"""getWorkingSpace(SbProjector self) -> SbMatrix"""
        return _coin.SbProjector_getWorkingSpace(self)

    def copy(self):
        r"""copy(SbProjector self) -> SbProjector"""
        return _coin.SbProjector_copy(self)

    def tryProject(self, point, epsilon, result):
        r"""tryProject(SbProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbProjector_tryProject(self, point, epsilon, result)

# Register SbProjector in _coin:
_coin.SbProjector_swigregister(SbProjector)
class SbCylinder(object):
    r"""Proxy of C++ SbCylinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbCylinder self) -> SbCylinder
        __init__(SbCylinder self, SbLine a, float const r) -> SbCylinder
        """
        _coin.SbCylinder_swiginit(self, _coin.new_SbCylinder(*args))

    def setValue(self, a, r):
        r"""setValue(SbCylinder self, SbLine a, float const r)"""
        return _coin.SbCylinder_setValue(self, a, r)

    def setAxis(self, a):
        r"""setAxis(SbCylinder self, SbLine a)"""
        return _coin.SbCylinder_setAxis(self, a)

    def setRadius(self, r):
        r"""setRadius(SbCylinder self, float const r)"""
        return _coin.SbCylinder_setRadius(self, r)

    def getAxis(self):
        r"""getAxis(SbCylinder self) -> SbLine"""
        return _coin.SbCylinder_getAxis(self)

    def getRadius(self):
        r"""getRadius(SbCylinder self) -> float"""
        return _coin.SbCylinder_getRadius(self)

    def intersect(self, *args):
        r"""
        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):
        r"""output(SbCylinder self, FILE * file)"""
        return _coin.SbCylinder_output(self, file)
    __swig_destroy__ = _coin.delete_SbCylinder

# Register SbCylinder in _coin:
_coin.SbCylinder_swigregister(SbCylinder)
class SbCylinderProjector(SbProjector):
    r"""Proxy of C++ SbCylinderProjector class."""

    thisown = property(lambda x: 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):
        r"""project(SbCylinderProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderProjector_project(self, point)

    def projectAndGetRotation(self, point, rot):
        r"""projectAndGetRotation(SbCylinderProjector self, SbVec2f point, SbRotation rot) -> SbVec3f"""
        return _coin.SbCylinderProjector_projectAndGetRotation(self, point, rot)

    def getRotation(self, point1, point2):
        r"""getRotation(SbCylinderProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderProjector_getRotation(self, point1, point2)

    def setCylinder(self, cyl):
        r"""setCylinder(SbCylinderProjector self, SbCylinder cyl)"""
        return _coin.SbCylinderProjector_setCylinder(self, cyl)

    def getCylinder(self):
        r"""getCylinder(SbCylinderProjector self) -> SbCylinder"""
        return _coin.SbCylinderProjector_getCylinder(self)

    def setOrientToEye(self, orienttoeye):
        r"""setOrientToEye(SbCylinderProjector self, SbBool const orienttoeye)"""
        return _coin.SbCylinderProjector_setOrientToEye(self, orienttoeye)

    def isOrientToEye(self):
        r"""isOrientToEye(SbCylinderProjector self) -> SbBool"""
        return _coin.SbCylinderProjector_isOrientToEye(self)

    def setFront(self, infront):
        r"""setFront(SbCylinderProjector self, SbBool const infront)"""
        return _coin.SbCylinderProjector_setFront(self, infront)

    def isFront(self):
        r"""isFront(SbCylinderProjector self) -> SbBool"""
        return _coin.SbCylinderProjector_isFront(self)

    def isPointInFront(self, point):
        r"""isPointInFront(SbCylinderProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbCylinderProjector_isPointInFront(self, point)

    def setWorkingSpace(self, space):
        r"""setWorkingSpace(SbCylinderProjector self, SbMatrix space)"""
        return _coin.SbCylinderProjector_setWorkingSpace(self, space)
    __swig_destroy__ = _coin.delete_SbCylinderProjector

# Register SbCylinderProjector in _coin:
_coin.SbCylinderProjector_swigregister(SbCylinderProjector)
class SbCylinderSectionProjector(SbCylinderProjector):
    r"""Proxy of C++ SbCylinderSectionProjector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbCylinderSectionProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderSectionProjector
        __init__(SbCylinderSectionProjector self, SbCylinder cyl, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderSectionProjector
        """
        _coin.SbCylinderSectionProjector_swiginit(self, _coin.new_SbCylinderSectionProjector(*args))

    def copy(self):
        r"""copy(SbCylinderSectionProjector self) -> SbProjector"""
        return _coin.SbCylinderSectionProjector_copy(self)

    def project(self, point):
        r"""project(SbCylinderSectionProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderSectionProjector_project(self, point)

    def getRotation(self, point1, point2):
        r"""getRotation(SbCylinderSectionProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderSectionProjector_getRotation(self, point1, point2)

    def setTolerance(self, edgetol):
        r"""setTolerance(SbCylinderSectionProjector self, float const edgetol)"""
        return _coin.SbCylinderSectionProjector_setTolerance(self, edgetol)

    def getTolerance(self):
        r"""getTolerance(SbCylinderSectionProjector self) -> float"""
        return _coin.SbCylinderSectionProjector_getTolerance(self)

    def isWithinTolerance(self, point):
        r"""isWithinTolerance(SbCylinderSectionProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbCylinderSectionProjector_isWithinTolerance(self, point)
    __swig_destroy__ = _coin.delete_SbCylinderSectionProjector

# Register SbCylinderSectionProjector in _coin:
_coin.SbCylinderSectionProjector_swigregister(SbCylinderSectionProjector)
class SbCylinderPlaneProjector(SbCylinderSectionProjector):
    r"""Proxy of C++ SbCylinderPlaneProjector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbCylinderPlaneProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderPlaneProjector
        __init__(SbCylinderPlaneProjector self, SbCylinder cyl, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbCylinderPlaneProjector
        """
        _coin.SbCylinderPlaneProjector_swiginit(self, _coin.new_SbCylinderPlaneProjector(*args))

    def copy(self):
        r"""copy(SbCylinderPlaneProjector self) -> SbProjector"""
        return _coin.SbCylinderPlaneProjector_copy(self)

    def project(self, point):
        r"""project(SbCylinderPlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderPlaneProjector_project(self, point)

    def getRotation(self, point1, point2):
        r"""getRotation(SbCylinderPlaneProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderPlaneProjector_getRotation(self, point1, point2)
    __swig_destroy__ = _coin.delete_SbCylinderPlaneProjector

# Register SbCylinderPlaneProjector in _coin:
_coin.SbCylinderPlaneProjector_swigregister(SbCylinderPlaneProjector)
class SbCylinderSheetProjector(SbCylinderProjector):
    r"""Proxy of C++ SbCylinderSheetProjector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbCylinderSheetProjector self, SbBool const orienttoeye=1) -> SbCylinderSheetProjector
        __init__(SbCylinderSheetProjector self, SbCylinder cyl, SbBool const orienttoeye=1) -> SbCylinderSheetProjector
        """
        _coin.SbCylinderSheetProjector_swiginit(self, _coin.new_SbCylinderSheetProjector(*args))

    def copy(self):
        r"""copy(SbCylinderSheetProjector self) -> SbProjector"""
        return _coin.SbCylinderSheetProjector_copy(self)

    def project(self, point):
        r"""project(SbCylinderSheetProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbCylinderSheetProjector_project(self, point)

    def getRotation(self, point1, point2):
        r"""getRotation(SbCylinderSheetProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbCylinderSheetProjector_getRotation(self, point1, point2)
    __swig_destroy__ = _coin.delete_SbCylinderSheetProjector

# Register SbCylinderSheetProjector in _coin:
_coin.SbCylinderSheetProjector_swigregister(SbCylinderSheetProjector)
class SbLineProjector(SbProjector):
    r"""Proxy of C++ SbLineProjector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SbLineProjector self) -> SbLineProjector"""
        _coin.SbLineProjector_swiginit(self, _coin.new_SbLineProjector())

    def copy(self):
        r"""copy(SbLineProjector self) -> SbProjector"""
        return _coin.SbLineProjector_copy(self)

    def project(self, point):
        r"""project(SbLineProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbLineProjector_project(self, point)

    def tryProject(self, point, epsilon, result):
        r"""tryProject(SbLineProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbLineProjector_tryProject(self, point, epsilon, result)

    def setLine(self, line):
        r"""setLine(SbLineProjector self, SbLine line)"""
        return _coin.SbLineProjector_setLine(self, line)

    def getLine(self):
        r"""getLine(SbLineProjector self) -> SbLine"""
        return _coin.SbLineProjector_getLine(self)

    def getVector(self, *args):
        r"""
        getVector(SbLineProjector self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f
        getVector(SbLineProjector self, SbVec2f viewpos) -> SbVec3f
        """
        return _coin.SbLineProjector_getVector(self, *args)

    def setStartPosition(self, *args):
        r"""
        setStartPosition(SbLineProjector self, SbVec2f viewpos)
        setStartPosition(SbLineProjector self, SbVec3f point)
        """
        return _coin.SbLineProjector_setStartPosition(self, *args)
    __swig_destroy__ = _coin.delete_SbLineProjector

# Register SbLineProjector in _coin:
_coin.SbLineProjector_swigregister(SbLineProjector)
class SbPlaneProjector(SbProjector):
    r"""Proxy of C++ SbPlaneProjector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbPlaneProjector self, SbBool const orient=0) -> SbPlaneProjector
        __init__(SbPlaneProjector self, SbPlane plane, SbBool const orient=0) -> SbPlaneProjector
        """
        _coin.SbPlaneProjector_swiginit(self, _coin.new_SbPlaneProjector(*args))

    def copy(self):
        r"""copy(SbPlaneProjector self) -> SbProjector"""
        return _coin.SbPlaneProjector_copy(self)

    def project(self, point):
        r"""project(SbPlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbPlaneProjector_project(self, point)

    def tryProject(self, point, epsilon, result):
        r"""tryProject(SbPlaneProjector self, SbVec2f point, float const epsilon, SbVec3f result) -> SbBool"""
        return _coin.SbPlaneProjector_tryProject(self, point, epsilon, result)

    def setPlane(self, plane):
        r"""setPlane(SbPlaneProjector self, SbPlane plane)"""
        return _coin.SbPlaneProjector_setPlane(self, plane)

    def getPlane(self):
        r"""getPlane(SbPlaneProjector self) -> SbPlane"""
        return _coin.SbPlaneProjector_getPlane(self)

    def setOrientToEye(self, orienttoeye):
        r"""setOrientToEye(SbPlaneProjector self, SbBool const orienttoeye)"""
        return _coin.SbPlaneProjector_setOrientToEye(self, orienttoeye)

    def isOrientToEye(self):
        r"""isOrientToEye(SbPlaneProjector self) -> SbBool"""
        return _coin.SbPlaneProjector_isOrientToEye(self)

    def getVector(self, *args):
        r"""
        getVector(SbPlaneProjector self, SbVec2f viewpos1, SbVec2f viewpos2) -> SbVec3f
        getVector(SbPlaneProjector self, SbVec2f viewpos) -> SbVec3f
        """
        return _coin.SbPlaneProjector_getVector(self, *args)

    def setStartPosition(self, *args):
        r"""
        setStartPosition(SbPlaneProjector self, SbVec2f viewpos)
        setStartPosition(SbPlaneProjector self, SbVec3f point)
        """
        return _coin.SbPlaneProjector_setStartPosition(self, *args)
    __swig_destroy__ = _coin.delete_SbPlaneProjector

# Register SbPlaneProjector in _coin:
_coin.SbPlaneProjector_swigregister(SbPlaneProjector)
class SbSphere(object):
    r"""Proxy of C++ SbSphere class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbSphere self) -> SbSphere
        __init__(SbSphere self, SbVec3f center, float const radius) -> SbSphere
        """
        _coin.SbSphere_swiginit(self, _coin.new_SbSphere(*args))

    def setValue(self, center, radius):
        r"""setValue(SbSphere self, SbVec3f center, float const radius)"""
        return _coin.SbSphere_setValue(self, center, radius)

    def setCenter(self, center):
        r"""setCenter(SbSphere self, SbVec3f center)"""
        return _coin.SbSphere_setCenter(self, center)

    def setRadius(self, radius):
        r"""setRadius(SbSphere self, float const radius)"""
        return _coin.SbSphere_setRadius(self, radius)

    def getCenter(self):
        r"""getCenter(SbSphere self) -> SbVec3f"""
        return _coin.SbSphere_getCenter(self)

    def getRadius(self):
        r"""getRadius(SbSphere self) -> float"""
        return _coin.SbSphere_getRadius(self)

    def circumscribe(self, box):
        r"""circumscribe(SbSphere self, SbBox3f box)"""
        return _coin.SbSphere_circumscribe(self, box)

    def intersect(self, *args):
        r"""
        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):
        r"""pointInside(SbSphere self, SbVec3f p) -> SbBool"""
        return _coin.SbSphere_pointInside(self, p)

    def output(self, file):
        r"""output(SbSphere self, FILE * file)"""
        return _coin.SbSphere_output(self, file)
    __swig_destroy__ = _coin.delete_SbSphere

# Register SbSphere in _coin:
_coin.SbSphere_swigregister(SbSphere)
class SbSphereProjector(SbProjector):
    r"""Proxy of C++ SbSphereProjector class."""

    thisown = property(lambda x: 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):
        r"""projectAndGetRotation(SbSphereProjector self, SbVec2f point, SbRotation rot) -> SbVec3f"""
        return _coin.SbSphereProjector_projectAndGetRotation(self, point, rot)

    def getRotation(self, point1, point2):
        r"""getRotation(SbSphereProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereProjector_getRotation(self, point1, point2)

    def setSphere(self, sph):
        r"""setSphere(SbSphereProjector self, SbSphere sph)"""
        return _coin.SbSphereProjector_setSphere(self, sph)

    def getSphere(self):
        r"""getSphere(SbSphereProjector self) -> SbSphere"""
        return _coin.SbSphereProjector_getSphere(self)

    def setOrientToEye(self, orienttoeye):
        r"""setOrientToEye(SbSphereProjector self, SbBool const orienttoeye)"""
        return _coin.SbSphereProjector_setOrientToEye(self, orienttoeye)

    def isOrientToEye(self):
        r"""isOrientToEye(SbSphereProjector self) -> SbBool"""
        return _coin.SbSphereProjector_isOrientToEye(self)

    def setFront(self, infront):
        r"""setFront(SbSphereProjector self, SbBool const infront)"""
        return _coin.SbSphereProjector_setFront(self, infront)

    def isFront(self):
        r"""isFront(SbSphereProjector self) -> SbBool"""
        return _coin.SbSphereProjector_isFront(self)

    def isPointInFront(self, point):
        r"""isPointInFront(SbSphereProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbSphereProjector_isPointInFront(self, point)

    def setWorkingSpace(self, space):
        r"""setWorkingSpace(SbSphereProjector self, SbMatrix space)"""
        return _coin.SbSphereProjector_setWorkingSpace(self, space)
    __swig_destroy__ = _coin.delete_SbSphereProjector

# Register SbSphereProjector in _coin:
_coin.SbSphereProjector_swigregister(SbSphereProjector)
class SbSphereSheetProjector(SbSphereProjector):
    r"""Proxy of C++ SbSphereSheetProjector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbSphereSheetProjector self, SbBool const orienttoeye=1) -> SbSphereSheetProjector
        __init__(SbSphereSheetProjector self, SbSphere sph, SbBool const orienttoeye=1) -> SbSphereSheetProjector
        """
        _coin.SbSphereSheetProjector_swiginit(self, _coin.new_SbSphereSheetProjector(*args))

    def copy(self):
        r"""copy(SbSphereSheetProjector self) -> SbProjector"""
        return _coin.SbSphereSheetProjector_copy(self)

    def project(self, point):
        r"""project(SbSphereSheetProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSphereSheetProjector_project(self, point)

    def getRotation(self, point1, point2):
        r"""getRotation(SbSphereSheetProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereSheetProjector_getRotation(self, point1, point2)
    __swig_destroy__ = _coin.delete_SbSphereSheetProjector

# Register SbSphereSheetProjector in _coin:
_coin.SbSphereSheetProjector_swigregister(SbSphereSheetProjector)
class SbSphereSectionProjector(SbSphereProjector):
    r"""Proxy of C++ SbSphereSectionProjector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbSphereSectionProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSphereSectionProjector
        __init__(SbSphereSectionProjector self, SbSphere sph, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSphereSectionProjector
        """
        _coin.SbSphereSectionProjector_swiginit(self, _coin.new_SbSphereSectionProjector(*args))

    def copy(self):
        r"""copy(SbSphereSectionProjector self) -> SbProjector"""
        return _coin.SbSphereSectionProjector_copy(self)

    def project(self, point):
        r"""project(SbSphereSectionProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSphereSectionProjector_project(self, point)

    def getRotation(self, point1, point2):
        r"""getRotation(SbSphereSectionProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSphereSectionProjector_getRotation(self, point1, point2)

    def setTolerance(self, edgetol):
        r"""setTolerance(SbSphereSectionProjector self, float const edgetol)"""
        return _coin.SbSphereSectionProjector_setTolerance(self, edgetol)

    def getTolerance(self):
        r"""getTolerance(SbSphereSectionProjector self) -> float"""
        return _coin.SbSphereSectionProjector_getTolerance(self)

    def setRadialFactor(self, rad=0.0):
        r"""setRadialFactor(SbSphereSectionProjector self, float const rad=0.0)"""
        return _coin.SbSphereSectionProjector_setRadialFactor(self, rad)

    def getRadialFactor(self):
        r"""getRadialFactor(SbSphereSectionProjector self) -> float"""
        return _coin.SbSphereSectionProjector_getRadialFactor(self)

    def isWithinTolerance(self, point):
        r"""isWithinTolerance(SbSphereSectionProjector self, SbVec3f point) -> SbBool"""
        return _coin.SbSphereSectionProjector_isWithinTolerance(self, point)
    __swig_destroy__ = _coin.delete_SbSphereSectionProjector

# Register SbSphereSectionProjector in _coin:
_coin.SbSphereSectionProjector_swigregister(SbSphereSectionProjector)
class SbSpherePlaneProjector(SbSphereSectionProjector):
    r"""Proxy of C++ SbSpherePlaneProjector class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbSpherePlaneProjector self, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSpherePlaneProjector
        __init__(SbSpherePlaneProjector self, SbSphere sph, float const edgetol=0.9, SbBool const orienttoeye=1) -> SbSpherePlaneProjector
        """
        _coin.SbSpherePlaneProjector_swiginit(self, _coin.new_SbSpherePlaneProjector(*args))

    def copy(self):
        r"""copy(SbSpherePlaneProjector self) -> SbProjector"""
        return _coin.SbSpherePlaneProjector_copy(self)

    def project(self, point):
        r"""project(SbSpherePlaneProjector self, SbVec2f point) -> SbVec3f"""
        return _coin.SbSpherePlaneProjector_project(self, point)

    def getRotation(self, point1, point2):
        r"""getRotation(SbSpherePlaneProjector self, SbVec3f point1, SbVec3f point2) -> SbRotation"""
        return _coin.SbSpherePlaneProjector_getRotation(self, point1, point2)
    __swig_destroy__ = _coin.delete_SbSpherePlaneProjector

# Register SbSpherePlaneProjector in _coin:
_coin.SbSpherePlaneProjector_swigregister(SbSpherePlaneProjector)
class SbClip(object):
    r"""Proxy of C++ SbClip class."""

    thisown = 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):
        r"""__init__(SbClip self, SbClipCallback * callback=None, void * userdata=None) -> SbClip"""
        _coin.SbClip_swiginit(self, _coin.new_SbClip(callback, userdata))

    def addVertex(self, v, vdata=None):
        r"""addVertex(SbClip self, SbVec3f v, void * vdata=None)"""
        return _coin.SbClip_addVertex(self, v, vdata)

    def reset(self):
        r"""reset(SbClip self)"""
        return _coin.SbClip_reset(self)

    def clip(self, plane):
        r"""clip(SbClip self, SbPlane plane)"""
        return _coin.SbClip_clip(self, plane)

    def getNumVertices(self):
        r"""getNumVertices(SbClip self) -> int"""
        return _coin.SbClip_getNumVertices(self)

    def getVertex(self, idx, v, vdata=None):
        r"""getVertex(SbClip self, int const idx, SbVec3f v, void ** vdata=None)"""
        return _coin.SbClip_getVertex(self, idx, v, vdata)

    def getVertexData(self, idx):
        r"""getVertexData(SbClip self, int const idx) -> void *"""
        return _coin.SbClip_getVertexData(self, idx)
    __swig_destroy__ = _coin.delete_SbClip

# Register SbClip in _coin:
_coin.SbClip_swigregister(SbClip)
class SbDPRotation(object):
    r"""Proxy of C++ SbDPRotation class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbDPRotation_swiginit(self, _coin.new_SbDPRotation(*args))

    def getValue(self):
        r"""getValue(SbDPRotation self) -> double const *"""
        return _coin.SbDPRotation_getValue(self)

    def getAxisAngle(self):
        r"""getAxisAngle(SbDPRotation self)"""
        return _coin.SbDPRotation_getAxisAngle(self)

    def getMatrix(self):
        r"""getMatrix(SbDPRotation self)"""
        return _coin.SbDPRotation_getMatrix(self)

    def invert(self):
        r"""invert(SbDPRotation self) -> SbDPRotation"""
        return _coin.SbDPRotation_invert(self)

    def inverse(self):
        r"""inverse(SbDPRotation self) -> SbDPRotation"""
        return _coin.SbDPRotation_inverse(self)

    def setValue(self, *args):
        r"""
        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):
        r"""
        __imul__(SbDPRotation self, SbDPRotation q) -> SbDPRotation
        __imul__(SbDPRotation self, double const s) -> SbDPRotation
        """
        return _coin.SbDPRotation___imul__(self, *args)

    def equals(self, r, tolerance):
        r"""equals(SbDPRotation self, SbDPRotation r, double const tolerance) -> SbBool"""
        return _coin.SbDPRotation_equals(self, r, tolerance)

    def multVec(self, src, dst):
        r"""multVec(SbDPRotation self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPRotation_multVec(self, src, dst)

    def scaleAngle(self, scaleFactor):
        r"""scaleAngle(SbDPRotation self, double const scaleFactor)"""
        return _coin.SbDPRotation_scaleAngle(self, scaleFactor)

    @staticmethod
    def slerp(rot0, rot1, t):
        r"""slerp(SbDPRotation rot0, SbDPRotation rot1, double t) -> SbDPRotation"""
        return _coin.SbDPRotation_slerp(rot0, rot1, t)

    @staticmethod
    def identity():
        r"""identity() -> SbDPRotation"""
        return _coin.SbDPRotation_identity()

    def output(self, fp):
        r"""output(SbDPRotation self, FILE * fp)"""
        return _coin.SbDPRotation_output(self, fp)

    def __mul__(self, *args):
        r"""
        __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):
        r"""__eq__(SbDPRotation self, SbDPRotation u) -> int"""
        return _coin.SbDPRotation___eq__(self, u)

    def __nq__(self, u):
        r"""__nq__(SbDPRotation self, SbDPRotation u) -> int"""
        return _coin.SbDPRotation___nq__(self, u)
    __swig_destroy__ = _coin.delete_SbDPRotation

# Register SbDPRotation in _coin:
_coin.SbDPRotation_swigregister(SbDPRotation)
class SbDPMatrix(object):
    r"""Proxy of C++ SbDPMatrix class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbDPMatrix_swiginit(self, _coin.new_SbDPMatrix(*args))
    __swig_destroy__ = _coin.delete_SbDPMatrix

    def setValue(self, m):
        r"""setValue(SbDPMatrix self, SbDPMat const & m)"""
        return _coin.SbDPMatrix_setValue(self, m)

    def makeIdentity(self):
        r"""makeIdentity(SbDPMatrix self)"""
        return _coin.SbDPMatrix_makeIdentity(self)

    def setRotate(self, q):
        r"""setRotate(SbDPMatrix self, SbDPRotation q)"""
        return _coin.SbDPMatrix_setRotate(self, q)

    def inverse(self):
        r"""inverse(SbDPMatrix self) -> SbDPMatrix"""
        return _coin.SbDPMatrix_inverse(self)

    def det3(self, *args):
        r"""
        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):
        r"""det4(SbDPMatrix self) -> double"""
        return _coin.SbDPMatrix_det4(self)

    def equals(self, m, tolerance):
        r"""equals(SbDPMatrix self, SbDPMatrix m, double tolerance) -> SbBool"""
        return _coin.SbDPMatrix_equals(self, m, tolerance)

    def __imul__(self, m):
        r"""__imul__(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix___imul__(self, m)

    def getValue(self, *args):
        r"""
        getValue(SbDPMatrix self) -> SbDPMat const
        getValue(SbDPMatrix self, SbDPMat & m)
        """
        return _coin.SbDPMatrix_getValue(self, *args)

    @staticmethod
    def identity():
        r"""identity() -> SbDPMatrix"""
        return _coin.SbDPMatrix_identity()

    def setScale(self, *args):
        r"""
        setScale(SbDPMatrix self, double const s)
        setScale(SbDPMatrix self, SbVec3d s)
        """
        return _coin.SbDPMatrix_setScale(self, *args)

    def setTranslate(self, t):
        r"""setTranslate(SbDPMatrix self, SbVec3d t)"""
        return _coin.SbDPMatrix_setTranslate(self, t)

    def setTransform(self, *args):
        r"""
        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):
        r"""
        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):
        r"""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):
        r"""LUDecomposition(SbDPMatrix self, int [4] index, double & d) -> SbBool"""
        return _coin.SbDPMatrix_LUDecomposition(self, index, d)

    def LUBackSubstitution(self, index, b):
        r"""LUBackSubstitution(SbDPMatrix self, int [4] index, double [4] b)"""
        return _coin.SbDPMatrix_LUBackSubstitution(self, index, b)

    def transpose(self):
        r"""transpose(SbDPMatrix self) -> SbDPMatrix"""
        return _coin.SbDPMatrix_transpose(self)

    def multRight(self, m):
        r"""multRight(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix_multRight(self, m)

    def multLeft(self, m):
        r"""multLeft(SbDPMatrix self, SbDPMatrix m) -> SbDPMatrix"""
        return _coin.SbDPMatrix_multLeft(self, m)

    def multMatrixVec(self, src, dst):
        r"""multMatrixVec(SbDPMatrix self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPMatrix_multMatrixVec(self, src, dst)

    def multDirMatrix(self, src, dst):
        r"""multDirMatrix(SbDPMatrix self, SbVec3d src, SbVec3d dst)"""
        return _coin.SbDPMatrix_multDirMatrix(self, src, dst)

    def multLineMatrix(self, src, dst):
        r"""multLineMatrix(SbDPMatrix self, SbDPLine src, SbDPLine dst)"""
        return _coin.SbDPMatrix_multLineMatrix(self, src, dst)

    def multVecMatrix(self, *args):
        r"""
        multVecMatrix(SbDPMatrix self, SbVec3d src, SbVec3d dst)
        multVecMatrix(SbDPMatrix self, SbVec4d src, SbVec4d dst)
        """
        return _coin.SbDPMatrix_multVecMatrix(self, *args)

    def output(self, fp):
        r"""output(SbDPMatrix self, FILE * fp)"""
        return _coin.SbDPMatrix_output(self, fp)

    def __mul__(self, *args):
        r"""
        __mul__(SbDPMatrix self, SbDPMatrix u) -> SbDPMatrix
        __mul__(SbDPMatrix self, SbVec3d u) -> SbVec3d
        """
        return _coin.SbDPMatrix___mul__(self, *args)

    def __rmul__(self, u):
        r"""__rmul__(SbDPMatrix self, SbVec3d u) -> SbVec3d"""
        return _coin.SbDPMatrix___rmul__(self, u)

    def __eq__(self, u):
        r"""__eq__(SbDPMatrix self, SbDPMatrix u) -> int"""
        return _coin.SbDPMatrix___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbDPMatrix self, SbDPMatrix u) -> int"""
        return _coin.SbDPMatrix___ne__(self, u)

# Register SbDPMatrix in _coin:
_coin.SbDPMatrix_swigregister(SbDPMatrix)
class SbDPLine(object):
    r"""Proxy of C++ SbDPLine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbDPLine self) -> SbDPLine
        __init__(SbDPLine self, SbVec3d p0, SbVec3d p1) -> SbDPLine
        """
        _coin.SbDPLine_swiginit(self, _coin.new_SbDPLine(*args))

    def setValue(self, p0, p1):
        r"""setValue(SbDPLine self, SbVec3d p0, SbVec3d p1)"""
        return _coin.SbDPLine_setValue(self, p0, p1)

    def getClosestPoints(self, line2, ptOnThis, ptOnLine2):
        r"""getClosestPoints(SbDPLine self, SbDPLine line2, SbVec3d ptOnThis, SbVec3d ptOnLine2) -> SbBool"""
        return _coin.SbDPLine_getClosestPoints(self, line2, ptOnThis, ptOnLine2)

    def getClosestPoint(self, point):
        r"""getClosestPoint(SbDPLine self, SbVec3d point) -> SbVec3d"""
        return _coin.SbDPLine_getClosestPoint(self, point)

    def getPosition(self):
        r"""getPosition(SbDPLine self) -> SbVec3d"""
        return _coin.SbDPLine_getPosition(self)

    def getDirection(self):
        r"""getDirection(SbDPLine self) -> SbVec3d"""
        return _coin.SbDPLine_getDirection(self)

    def output(self, file):
        r"""output(SbDPLine self, FILE * file)"""
        return _coin.SbDPLine_output(self, file)
    __swig_destroy__ = _coin.delete_SbDPLine

# Register SbDPLine in _coin:
_coin.SbDPLine_swigregister(SbDPLine)
class SbDPPlane(object):
    r"""Proxy of C++ SbDPPlane class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __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
        """
        _coin.SbDPPlane_swiginit(self, _coin.new_SbDPPlane(*args))

    def offset(self, d):
        r"""offset(SbDPPlane self, double const d)"""
        return _coin.SbDPPlane_offset(self, d)

    def transform(self):
        r"""transform(SbDPPlane self)"""
        return _coin.SbDPPlane_transform(self)

    def isInHalfSpace(self, point):
        r"""isInHalfSpace(SbDPPlane self, SbVec3d point) -> SbBool"""
        return _coin.SbDPPlane_isInHalfSpace(self, point)

    def getDistance(self, point):
        r"""getDistance(SbDPPlane self, SbVec3d point) -> double"""
        return _coin.SbDPPlane_getDistance(self, point)

    def getNormal(self):
        r"""getNormal(SbDPPlane self) -> SbVec3d"""
        return _coin.SbDPPlane_getNormal(self)

    def getDistanceFromOrigin(self):
        r"""getDistanceFromOrigin(SbDPPlane self) -> double"""
        return _coin.SbDPPlane_getDistanceFromOrigin(self)

    def output(self, file):
        r"""output(SbDPPlane self, FILE * file)"""
        return _coin.SbDPPlane_output(self, file)

    def intersect(self, *args):
        r"""
        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):
        r"""__eq__(SbDPPlane self, SbDPPlane u) -> int"""
        return _coin.SbDPPlane___eq__(self, u)

    def __ne__(self, u):
        r"""__ne__(SbDPPlane self, SbDPPlane u) -> int"""
        return _coin.SbDPPlane___ne__(self, u)
    __swig_destroy__ = _coin.delete_SbDPPlane

# Register SbDPPlane in _coin:
_coin.SbDPPlane_swigregister(SbDPPlane)
class SbHeapFuncs(object):
    r"""Proxy of C++ SbHeapFuncs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    eval_func = property(_coin.SbHeapFuncs_eval_func_get, _coin.SbHeapFuncs_eval_func_set, doc=r"""eval_func : p.f(p.void).float""")
    get_index_func = property(_coin.SbHeapFuncs_get_index_func_get, _coin.SbHeapFuncs_get_index_func_set, doc=r"""get_index_func : p.f(p.void).int""")
    set_index_func = property(_coin.SbHeapFuncs_set_index_func_get, _coin.SbHeapFuncs_set_index_func_set, doc=r"""set_index_func : p.f(p.void,int).void""")

    def __init__(self):
        r"""__init__(SbHeapFuncs self) -> SbHeapFuncs"""
        _coin.SbHeapFuncs_swiginit(self, _coin.new_SbHeapFuncs())
    __swig_destroy__ = _coin.delete_SbHeapFuncs

# Register SbHeapFuncs in _coin:
_coin.SbHeapFuncs_swigregister(SbHeapFuncs)
class SbHeap(object):
    r"""Proxy of C++ SbHeap class."""

    thisown = 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):
        r"""__init__(SbHeap self, SbHeapFuncs SbHeapFuncs, int const initsize=1024) -> SbHeap"""
        _coin.SbHeap_swiginit(self, _coin.new_SbHeap(SbHeapFuncs, initsize))
    __swig_destroy__ = _coin.delete_SbHeap

    def emptyHeap(self):
        r"""emptyHeap(SbHeap self)"""
        return _coin.SbHeap_emptyHeap(self)

    def size(self):
        r"""size(SbHeap self) -> int"""
        return _coin.SbHeap_size(self)

    def add(self, obj):
        r"""add(SbHeap self, void * obj) -> int"""
        return _coin.SbHeap_add(self, obj)

    def remove(self, *args):
        r"""
        remove(SbHeap self, int const pos)
        remove(SbHeap self, void * obj)
        """
        return _coin.SbHeap_remove(self, *args)

    def extractMin(self):
        r"""extractMin(SbHeap self) -> void *"""
        return _coin.SbHeap_extractMin(self)

    def getMin(self):
        r"""getMin(SbHeap self) -> void *"""
        return _coin.SbHeap_getMin(self)

    def newWeight(self, obj, hpos=-1):
        r"""newWeight(SbHeap self, void * obj, int hpos=-1)"""
        return _coin.SbHeap_newWeight(self, obj, hpos)

    def buildHeap(self, progresscb=None, data=None):
        r"""buildHeap(SbHeap self, SbBool (*)(float,void *) progresscb=None, void * data=None) -> SbBool"""
        return _coin.SbHeap_buildHeap(self, progresscb, data)

    def traverseHeap(self, func, userdata):
        r"""traverseHeap(SbHeap self, SbBool (*)(void *,void *) func, void * userdata) -> SbBool"""
        return _coin.SbHeap_traverseHeap(self, func, userdata)

# Register SbHeap in _coin:
_coin.SbHeap_swigregister(SbHeap)
class SbImage(object):
    r"""Proxy of C++ SbImage class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbImage self) -> SbImage
        __init__(SbImage self, unsigned char const * bytes) -> SbImage
        __init__(SbImage self, unsigned char const * bytes) -> SbImage
        """
        _coin.SbImage_swiginit(self, _coin.new_SbImage(*args))
    __swig_destroy__ = _coin.delete_SbImage

    def setValue(self, *args):
        r"""
        setValue(SbImage self, SbVec2s size)
        setValue(SbImage self, SbVec3s size)
        """
        return _coin.SbImage_setValue(self, *args)

    def setValuePtr(self, *args):
        r"""
        setValuePtr(SbImage self, SbVec2s size)
        setValuePtr(SbImage self, SbVec3s size)
        """
        return _coin.SbImage_setValuePtr(self, *args)

    def getSize(self):
        r"""getSize(SbImage self) -> SbVec3s"""
        return _coin.SbImage_getSize(self)

    def readFile(self, filename, searchdirectories=None, numdirectories=0):
        r"""readFile(SbImage self, SbString filename, SbString const *const * searchdirectories=None, int const numdirectories=0) -> SbBool"""
        return _coin.SbImage_readFile(self, filename, searchdirectories, numdirectories)

    def __eq__(self, image):
        r"""__eq__(SbImage self, SbImage image) -> int"""
        return _coin.SbImage___eq__(self, image)

    def __ne__(self, image):
        r"""__ne__(SbImage self, SbImage image) -> int"""
        return _coin.SbImage___ne__(self, image)

    @staticmethod
    def addReadImageCB(cb, closure):
        r"""addReadImageCB(SbImageReadImageCB * cb, void * closure)"""
        return _coin.SbImage_addReadImageCB(cb, closure)

    @staticmethod
    def removeReadImageCB(cb, closure):
        r"""removeReadImageCB(SbImageReadImageCB * cb, void * closure)"""
        return _coin.SbImage_removeReadImageCB(cb, closure)

    @staticmethod
    def searchForFile(basename, dirlist, numdirs):
        r"""searchForFile(SbString basename, SbString const *const * dirlist, int const numdirs) -> SbString"""
        return _coin.SbImage_searchForFile(basename, dirlist, numdirs)

    def hasData(self):
        r"""hasData(SbImage self) -> SbBool"""
        return _coin.SbImage_hasData(self)

    def readLock(self):
        r"""readLock(SbImage self)"""
        return _coin.SbImage_readLock(self)

    def readUnlock(self):
        r"""readUnlock(SbImage self)"""
        return _coin.SbImage_readUnlock(self)

    def scheduleReadFile(self, cb, closure, filename, searchdirectories=None, numdirectories=0):
        r"""scheduleReadFile(SbImage self, SbImageScheduleReadCB * cb, void * closure, SbString filename, SbString const *const * searchdirectories=None, int const numdirectories=0) -> SbBool"""
        return _coin.SbImage_scheduleReadFile(self, cb, closure, filename, searchdirectories, numdirectories)

    def getValue(self, *args):
        r"""
        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)

# Register SbImage in _coin:
_coin.SbImage_swigregister(SbImage)
class SbOctTreeFuncs(object):
    r"""Proxy of C++ SbOctTreeFuncs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ptinsidefunc = property(_coin.SbOctTreeFuncs_ptinsidefunc_get, _coin.SbOctTreeFuncs_ptinsidefunc_set, doc=r"""ptinsidefunc : p.f(q(const).p.void,r.q(const).SbVec3f).SbBool""")
    insideboxfunc = property(_coin.SbOctTreeFuncs_insideboxfunc_get, _coin.SbOctTreeFuncs_insideboxfunc_set, doc=r"""insideboxfunc : p.f(q(const).p.void,r.q(const).SbBox3f).SbBool""")
    insidespherefunc = property(_coin.SbOctTreeFuncs_insidespherefunc_get, _coin.SbOctTreeFuncs_insidespherefunc_set, doc=r"""insidespherefunc : p.f(q(const).p.void,r.q(const).SbSphere).SbBool""")
    insideplanesfunc = property(_coin.SbOctTreeFuncs_insideplanesfunc_get, _coin.SbOctTreeFuncs_insideplanesfunc_set, doc=r"""insideplanesfunc : p.f(q(const).p.void,q(const).p.q(const).SbPlane,q(const).int).SbBool""")

    def __init__(self):
        r"""__init__(SbOctTreeFuncs self) -> SbOctTreeFuncs"""
        _coin.SbOctTreeFuncs_swiginit(self, _coin.new_SbOctTreeFuncs())
    __swig_destroy__ = _coin.delete_SbOctTreeFuncs

# Register SbOctTreeFuncs in _coin:
_coin.SbOctTreeFuncs_swigregister(SbOctTreeFuncs)
class SbOctTree(object):
    r"""Proxy of C++ SbOctTree class."""

    thisown = 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):
        r"""__init__(SbOctTree self, SbBox3f bbox, SbOctTreeFuncs itemfuncs, int const maxitemspernode=64) -> SbOctTree"""
        _coin.SbOctTree_swiginit(self, _coin.new_SbOctTree(bbox, itemfuncs, maxitemspernode))
    __swig_destroy__ = _coin.delete_SbOctTree

    def addItem(self, item):
        r"""addItem(SbOctTree self, void *const item)"""
        return _coin.SbOctTree_addItem(self, item)

    def removeItem(self, item):
        r"""removeItem(SbOctTree self, void *const item)"""
        return _coin.SbOctTree_removeItem(self, item)

    def findItems(self, *args):
        r"""
        findItems(SbOctTree self, SbVec3f pos, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbBox3f box, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbSphere sphere, SbList< void * > & destarray, SbBool const removeduplicates=1)
        findItems(SbOctTree self, SbPlane planes, int const numplanes, SbList< void * > & destarray, SbBool const removeduplicates=1)
        """
        return _coin.SbOctTree_findItems(self, *args)

    def getBoundingBox(self):
        r"""getBoundingBox(SbOctTree self) -> SbBox3f"""
        return _coin.SbOctTree_getBoundingBox(self)

    def clear(self):
        r"""clear(SbOctTree self)"""
        return _coin.SbOctTree_clear(self)

    def debugTree(self, fp):
        r"""debugTree(SbOctTree self, FILE * fp)"""
        return _coin.SbOctTree_debugTree(self, fp)

# Register SbOctTree in _coin:
_coin.SbOctTree_swigregister(SbOctTree)
class SbTesselator(object):
    r"""Proxy of C++ SbTesselator class."""

    thisown = 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):
        r"""__init__(SbTesselator self, SbTesselatorCB * func=None, void * data=None) -> SbTesselator"""
        _coin.SbTesselator_swiginit(self, _coin.new_SbTesselator(func, data))
    __swig_destroy__ = _coin.delete_SbTesselator

    def beginPolygon(self, *args):
        r"""beginPolygon(SbTesselator self, SbBool keepVertices=0, SbVec3f normal=SbVec3f(0.0f, 0.0f, 0.0f))"""
        return _coin.SbTesselator_beginPolygon(self, *args)

    def addVertex(self, v, data):
        r"""addVertex(SbTesselator self, SbVec3f v, void * data)"""
        return _coin.SbTesselator_addVertex(self, v, data)

    def endPolygon(self):
        r"""endPolygon(SbTesselator self)"""
        return _coin.SbTesselator_endPolygon(self)

    def setCallback(self, func, data):
        r"""setCallback(SbTesselator self, SbTesselatorCB * func, void * data)"""
        return _coin.SbTesselator_setCallback(self, func, data)

# Register SbTesselator in _coin:
_coin.SbTesselator_swigregister(SbTesselator)
class SoTimerQueueSensor(SoSensor):
    r"""Proxy of C++ SoTimerQueueSensor class."""

    thisown = 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 = _coin.new_SoTimerQueueSensor_scb_v(*args)
       else:
          self.this = _coin.new_SoTimerQueueSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoTimerQueueSensor

    def getTriggerTime(self):
        r"""getTriggerTime(SoTimerQueueSensor self) -> SbTime"""
        return _coin.SoTimerQueueSensor_getTriggerTime(self)

    def schedule(self):
        r"""schedule(SoTimerQueueSensor self)"""
        return _coin.SoTimerQueueSensor_schedule(self)

    def unschedule(self):
        r"""unschedule(SoTimerQueueSensor self)"""
        return _coin.SoTimerQueueSensor_unschedule(self)

    def isScheduled(self):
        r"""isScheduled(SoTimerQueueSensor self) -> SbBool"""
        return _coin.SoTimerQueueSensor_isScheduled(self)

    def trigger(self):
        r"""trigger(SoTimerQueueSensor self)"""
        return _coin.SoTimerQueueSensor_trigger(self)

# Register SoTimerQueueSensor in _coin:
_coin.SoTimerQueueSensor_swigregister(SoTimerQueueSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoTimerQueueSensor *"))
      newobj = _coin.new_SoTimerQueueSensor_scb_v(*args)
   else:
      self.this = _coin.new_SoTimerQueueSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoAlarmSensor(SoTimerQueueSensor):
    r"""Proxy of C++ SoAlarmSensor class."""

    thisown = 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 = _coin.new_SoAlarmSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoAlarmSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoAlarmSensor

    def setTime(self, abstime):
        r"""setTime(SoAlarmSensor self, SbTime abstime)"""
        return _coin.SoAlarmSensor_setTime(self, abstime)

    def setTimeFromNow(self, reltime):
        r"""setTimeFromNow(SoAlarmSensor self, SbTime reltime)"""
        return _coin.SoAlarmSensor_setTimeFromNow(self, reltime)

    def getTime(self):
        r"""getTime(SoAlarmSensor self) -> SbTime"""
        return _coin.SoAlarmSensor_getTime(self)

    def schedule(self):
        r"""schedule(SoAlarmSensor self)"""
        return _coin.SoAlarmSensor_schedule(self)

# Register SoAlarmSensor in _coin:
_coin.SoAlarmSensor_swigregister(SoAlarmSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoAlarmSensor *"))
      newobj = _coin.new_SoAlarmSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoAlarmSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoIdleSensor(SoDelayQueueSensor):
    r"""Proxy of C++ SoIdleSensor class."""

    thisown = 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 = _coin.new_SoIdleSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoIdleSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoIdleSensor

# Register SoIdleSensor in _coin:
_coin.SoIdleSensor_swigregister(SoIdleSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoIdleSensor *"))
      newobj = _coin.new_SoIdleSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoIdleSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoNodeSensor(SoDataSensor):
    r"""Proxy of C++ SoNodeSensor class."""

    thisown = 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 = _coin.new_SoNodeSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoNodeSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoNodeSensor

    def attach(self, node):
        r"""attach(SoNodeSensor self, SoNode node)"""
        return _coin.SoNodeSensor_attach(self, node)

    def detach(self):
        r"""detach(SoNodeSensor self)"""
        return _coin.SoNodeSensor_detach(self)

    def getAttachedNode(self):
        r"""getAttachedNode(SoNodeSensor self) -> SoNode"""
        return _coin.SoNodeSensor_getAttachedNode(self)

# Register SoNodeSensor in _coin:
_coin.SoNodeSensor_swigregister(SoNodeSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoNodeSensor *"))
      newobj = _coin.new_SoNodeSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoNodeSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoOneShotSensor(SoDelayQueueSensor):
    r"""Proxy of C++ SoOneShotSensor class."""

    thisown = 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 = _coin.new_SoOneShotSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoOneShotSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoOneShotSensor

# Register SoOneShotSensor in _coin:
_coin.SoOneShotSensor_swigregister(SoOneShotSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoOneShotSensor *"))
      newobj = _coin.new_SoOneShotSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoOneShotSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoPathSensor(SoDataSensor):
    r"""Proxy of C++ SoPathSensor class."""

    thisown = 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 = _coin.new_SoPathSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoPathSensor(*args)
       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoPathSensor
    PATH = _coin.SoPathSensor_PATH
    
    NODES = _coin.SoPathSensor_NODES
    
    PATH_AND_NODES = _coin.SoPathSensor_PATH_AND_NODES
    

    def setTriggerFilter(self, type):
        r"""setTriggerFilter(SoPathSensor self, SoPathSensor::TriggerFilter const type)"""
        return _coin.SoPathSensor_setTriggerFilter(self, type)

    def getTriggerFilter(self):
        r"""getTriggerFilter(SoPathSensor self) -> SoPathSensor::TriggerFilter"""
        return _coin.SoPathSensor_getTriggerFilter(self)

    def attach(self, path):
        r"""attach(SoPathSensor self, SoPath path)"""
        return _coin.SoPathSensor_attach(self, path)

    def detach(self):
        r"""detach(SoPathSensor self)"""
        return _coin.SoPathSensor_detach(self)

    def getAttachedPath(self):
        r"""getAttachedPath(SoPathSensor self) -> SoPath"""
        return _coin.SoPathSensor_getAttachedPath(self)

# Register SoPathSensor in _coin:
_coin.SoPathSensor_swigregister(SoPathSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoPathSensor *"))
      newobj = _coin.new_SoPathSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoPathSensor(*args)
   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoTimerSensor(SoTimerQueueSensor):
    r"""Proxy of C++ SoTimerSensor class."""

    thisown = 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 = _coin.new_SoTimerSensor_scb_v(*args)
       else:
          newobj = _coin.new_SoTimerSensor(*args)


       if newobj:
          self.this = newobj.this
          self.thisown = 1


    __swig_destroy__ = _coin.delete_SoTimerSensor

    def setBaseTime(self, base):
        r"""setBaseTime(SoTimerSensor self, SbTime base)"""
        return _coin.SoTimerSensor_setBaseTime(self, base)

    def getBaseTime(self):
        r"""getBaseTime(SoTimerSensor self) -> SbTime"""
        return _coin.SoTimerSensor_getBaseTime(self)

    def setInterval(self, interval):
        r"""setInterval(SoTimerSensor self, SbTime interval)"""
        return _coin.SoTimerSensor_setInterval(self, interval)

    def getInterval(self):
        r"""getInterval(SoTimerSensor self) -> SbTime"""
        return _coin.SoTimerSensor_getInterval(self)

    def schedule(self):
        r"""schedule(SoTimerSensor self)"""
        return _coin.SoTimerSensor_schedule(self)

    def unschedule(self):
        r"""unschedule(SoTimerSensor self)"""
        return _coin.SoTimerSensor_unschedule(self)

    def reschedule(self, schedtime):
        r"""reschedule(SoTimerSensor self, SbTime schedtime)"""
        return _coin.SoTimerSensor_reschedule(self, schedtime)

# Register SoTimerSensor in _coin:
_coin.SoTimerSensor_swigregister(SoTimerSensor)

def __init__(self, *args):
   newobj = None
   if len(args) == 2:
      args = (args[0], (args[0], args[1], "SoTimerSensor *"))
      newobj = _coin.new_SoTimerSensor_scb_v(*args)
   else:
      newobj = _coin.new_SoTimerSensor(*args)


   if newobj:
      self.this = newobj.this
      self.thisown = 1



class SoInteraction(object):
    r"""Proxy of C++ SoInteraction class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def init():
        r"""init()"""
        return _coin.SoInteraction_init()

    def __init__(self):
        r"""__init__(SoInteraction self) -> SoInteraction"""
        _coin.SoInteraction_swiginit(self, _coin.new_SoInteraction())
    __swig_destroy__ = _coin.delete_SoInteraction

# Register SoInteraction in _coin:
_coin.SoInteraction_swigregister(SoInteraction)
class SoOffscreenRenderer(object):
    r"""Proxy of C++ SoOffscreenRenderer class."""

    thisown = 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):
        r"""
        __init__(SoOffscreenRenderer self, SbViewportRegion viewportregion) -> SoOffscreenRenderer
        __init__(SoOffscreenRenderer self, SoGLRenderAction action) -> SoOffscreenRenderer
        """
        _coin.SoOffscreenRenderer_swiginit(self, _coin.new_SoOffscreenRenderer(*args))
    __swig_destroy__ = _coin.delete_SoOffscreenRenderer

    @staticmethod
    def getScreenPixelsPerInch():
        r"""getScreenPixelsPerInch() -> float"""
        return _coin.SoOffscreenRenderer_getScreenPixelsPerInch()

    @staticmethod
    def getMaximumResolution():
        r"""getMaximumResolution() -> SbVec2s"""
        return _coin.SoOffscreenRenderer_getMaximumResolution()

    def setComponents(self, components):
        r"""setComponents(SoOffscreenRenderer self, SoOffscreenRenderer::Components const components)"""
        return _coin.SoOffscreenRenderer_setComponents(self, components)

    def getComponents(self):
        r"""getComponents(SoOffscreenRenderer self) -> SoOffscreenRenderer::Components"""
        return _coin.SoOffscreenRenderer_getComponents(self)

    def setViewportRegion(self, region):
        r"""setViewportRegion(SoOffscreenRenderer self, SbViewportRegion region)"""
        return _coin.SoOffscreenRenderer_setViewportRegion(self, region)

    def getViewportRegion(self):
        r"""getViewportRegion(SoOffscreenRenderer self) -> SbViewportRegion"""
        return _coin.SoOffscreenRenderer_getViewportRegion(self)

    def setBackgroundColor(self, color):
        r"""setBackgroundColor(SoOffscreenRenderer self, SbColor color)"""
        return _coin.SoOffscreenRenderer_setBackgroundColor(self, color)

    def getBackgroundColor(self):
        r"""getBackgroundColor(SoOffscreenRenderer self) -> SbColor"""
        return _coin.SoOffscreenRenderer_getBackgroundColor(self)

    def setGLRenderAction(self, action):
        r"""setGLRenderAction(SoOffscreenRenderer self, SoGLRenderAction action)"""
        return _coin.SoOffscreenRenderer_setGLRenderAction(self, action)

    def getGLRenderAction(self):
        r"""getGLRenderAction(SoOffscreenRenderer self) -> SoGLRenderAction"""
        return _coin.SoOffscreenRenderer_getGLRenderAction(self)

    def render(self, *args):
        r"""
        render(SoOffscreenRenderer self, SoNode scene) -> SbBool
        render(SoOffscreenRenderer self, SoPath scene) -> SbBool
        """
        return _coin.SoOffscreenRenderer_render(self, *args)

    def getDC(self):
        r"""getDC(SoOffscreenRenderer self) -> void const *const &"""
        return _coin.SoOffscreenRenderer_getDC(self)

    def writeToRGB(self, *args):
        r"""
        writeToRGB(SoOffscreenRenderer self, FILE * fp) -> SbBool
        writeToRGB(SoOffscreenRenderer self, char const * filename) -> SbBool
        """
        return _coin.SoOffscreenRenderer_writeToRGB(self, *args)

    def writeToPostScript(self, *args):
        r"""
        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):
        r"""isWriteSupported(SoOffscreenRenderer self, SbName filetypeextension) -> SbBool"""
        return _coin.SoOffscreenRenderer_isWriteSupported(self, filetypeextension)

    def getNumWriteFiletypes(self):
        r"""getNumWriteFiletypes(SoOffscreenRenderer self) -> int"""
        return _coin.SoOffscreenRenderer_getNumWriteFiletypes(self)

    def writeToFile(self, filename, filetypeextension):
        r"""writeToFile(SoOffscreenRenderer self, SbString filename, SbName filetypeextension) -> SbBool"""
        return _coin.SoOffscreenRenderer_writeToFile(self, filename, filetypeextension)

    def setPbufferEnable(self, enable):
        r"""setPbufferEnable(SoOffscreenRenderer self, SbBool enable)"""
        return _coin.SoOffscreenRenderer_setPbufferEnable(self, enable)

    def getPbufferEnable(self):
        r"""getPbufferEnable(SoOffscreenRenderer self) -> SbBool"""
        return _coin.SoOffscreenRenderer_getPbufferEnable(self)

    def getWriteFiletypeInfo(self, *args):
        r"""
        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):
        r"""
        getBuffer(SoOffscreenRenderer self) -> unsigned char
        getBuffer(SoOffscreenRenderer self) -> PyObject *
        """
        return _coin.SoOffscreenRenderer_getBuffer(self, *args)

# Register SoOffscreenRenderer in _coin:
_coin.SoOffscreenRenderer_swigregister(SoOffscreenRenderer)
class SoPickedPoint(object):
    r"""Proxy of C++ SoPickedPoint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoPickedPoint self, SoPickedPoint pp) -> SoPickedPoint
        __init__(SoPickedPoint self, SoPath path, SoState state, SbVec3f objSpacePoint) -> SoPickedPoint
        """
        _coin.SoPickedPoint_swiginit(self, _coin.new_SoPickedPoint(*args))
    __swig_destroy__ = _coin.delete_SoPickedPoint

    def copy(self):
        r"""copy(SoPickedPoint self) -> SoPickedPoint"""
        return _coin.SoPickedPoint_copy(self)

    def getPoint(self):
        r"""getPoint(SoPickedPoint self) -> SbVec3f"""
        return _coin.SoPickedPoint_getPoint(self)

    def getNormal(self):
        r"""getNormal(SoPickedPoint self) -> SbVec3f"""
        return _coin.SoPickedPoint_getNormal(self)

    def getTextureCoords(self):
        r"""getTextureCoords(SoPickedPoint self) -> SbVec4f"""
        return _coin.SoPickedPoint_getTextureCoords(self)

    def getMaterialIndex(self):
        r"""getMaterialIndex(SoPickedPoint self) -> int"""
        return _coin.SoPickedPoint_getMaterialIndex(self)

    def getPath(self):
        r"""getPath(SoPickedPoint self) -> SoPath"""
        return _coin.SoPickedPoint_getPath(self)

    def isOnGeometry(self):
        r"""isOnGeometry(SoPickedPoint self) -> SbBool"""
        return _coin.SoPickedPoint_isOnGeometry(self)

    def getDetail(self, node=None):
        r"""getDetail(SoPickedPoint self, SoNode node=None) -> SoDetail"""
        return _coin.SoPickedPoint_getDetail(self, node)

    def getObjectToWorld(self, node=None):
        r"""getObjectToWorld(SoPickedPoint self, SoNode node=None) -> SbMatrix"""
        return _coin.SoPickedPoint_getObjectToWorld(self, node)

    def getWorldToObject(self, node=None):
        r"""getWorldToObject(SoPickedPoint self, SoNode node=None) -> SbMatrix"""
        return _coin.SoPickedPoint_getWorldToObject(self, node)

    def getObjectToImage(self, node=None):
        r"""getObjectToImage(SoPickedPoint self, SoNode node=None) -> SbMatrix"""
        return _coin.SoPickedPoint_getObjectToImage(self, node)

    def getImageToObject(self, node=None):
        r"""getImageToObject(SoPickedPoint self, SoNode node=None) -> SbMatrix"""
        return _coin.SoPickedPoint_getImageToObject(self, node)

    def getObjectPoint(self, node=None):
        r"""getObjectPoint(SoPickedPoint self, SoNode node=None) -> SbVec3f"""
        return _coin.SoPickedPoint_getObjectPoint(self, node)

    def getObjectNormal(self, node=None):
        r"""getObjectNormal(SoPickedPoint self, SoNode node=None) -> SbVec3f"""
        return _coin.SoPickedPoint_getObjectNormal(self, node)

    def getObjectTextureCoords(self, node=None):
        r"""getObjectTextureCoords(SoPickedPoint self, SoNode node=None) -> SbVec4f"""
        return _coin.SoPickedPoint_getObjectTextureCoords(self, node)

    def setObjectNormal(self, normal):
        r"""setObjectNormal(SoPickedPoint self, SbVec3f normal)"""
        return _coin.SoPickedPoint_setObjectNormal(self, normal)

    def setObjectTextureCoords(self, texCoords):
        r"""setObjectTextureCoords(SoPickedPoint self, SbVec4f texCoords)"""
        return _coin.SoPickedPoint_setObjectTextureCoords(self, texCoords)

    def setMaterialIndex(self, index):
        r"""setMaterialIndex(SoPickedPoint self, int const index)"""
        return _coin.SoPickedPoint_setMaterialIndex(self, index)

    def setDetail(self, detail, node):
        r"""setDetail(SoPickedPoint self, SoDetail detail, SoNode node)"""
        return _coin.SoPickedPoint_setDetail(self, detail, node)

# Register SoPickedPoint in _coin:
_coin.SoPickedPoint_swigregister(SoPickedPoint)
class SoPrimitiveVertex(object):
    r"""Proxy of C++ SoPrimitiveVertex class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SoPrimitiveVertex self) -> SoPrimitiveVertex
        __init__(SoPrimitiveVertex self, SoPrimitiveVertex pv) -> SoPrimitiveVertex
        """
        _coin.SoPrimitiveVertex_swiginit(self, _coin.new_SoPrimitiveVertex(*args))
    __swig_destroy__ = _coin.delete_SoPrimitiveVertex

    def getPoint(self):
        r"""getPoint(SoPrimitiveVertex self) -> SbVec3f"""
        return _coin.SoPrimitiveVertex_getPoint(self)

    def getNormal(self):
        r"""getNormal(SoPrimitiveVertex self) -> SbVec3f"""
        return _coin.SoPrimitiveVertex_getNormal(self)

    def getTextureCoords(self):
        r"""getTextureCoords(SoPrimitiveVertex self) -> SbVec4f"""
        return _coin.SoPrimitiveVertex_getTextureCoords(self)

    def getMaterialIndex(self):
        r"""getMaterialIndex(SoPrimitiveVertex self) -> int"""
        return _coin.SoPrimitiveVertex_getMaterialIndex(self)

    def getPackedColor(self):
        r"""getPackedColor(SoPrimitiveVertex self) -> uint32_t"""
        return _coin.SoPrimitiveVertex_getPackedColor(self)

    def getDetail(self):
        r"""getDetail(SoPrimitiveVertex self) -> SoDetail"""
        return _coin.SoPrimitiveVertex_getDetail(self)

    def setPoint(self, *args):
        r"""
        setPoint(SoPrimitiveVertex self, SbVec3f pt)
        setPoint(SoPrimitiveVertex self, float x, float y, float z)
        """
        return _coin.SoPrimitiveVertex_setPoint(self, *args)

    def setNormal(self, *args):
        r"""
        setNormal(SoPrimitiveVertex self, SbVec3f n)
        setNormal(SoPrimitiveVertex self, float nx, float ny, float nz)
        """
        return _coin.SoPrimitiveVertex_setNormal(self, *args)

    def setTextureCoords(self, *args):
        r"""
        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):
        r"""setMaterialIndex(SoPrimitiveVertex self, int index)"""
        return _coin.SoPrimitiveVertex_setMaterialIndex(self, index)

    def setPackedColor(self, rgba):
        r"""setPackedColor(SoPrimitiveVertex self, uint32_t rgba)"""
        return _coin.SoPrimitiveVertex_setPackedColor(self, rgba)

    def setDetail(self, d):
        r"""setDetail(SoPrimitiveVertex self, SoDetail d)"""
        return _coin.SoPrimitiveVertex_setDetail(self, d)

# Register SoPrimitiveVertex in _coin:
_coin.SoPrimitiveVertex_swigregister(SoPrimitiveVertex)
class SoSceneManager(object):
    r"""Proxy of C++ SoSceneManager class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoSceneManager self) -> SoSceneManager"""
        _coin.SoSceneManager_swiginit(self, _coin.new_SoSceneManager())
    __swig_destroy__ = _coin.delete_SoSceneManager

    def render(self, *args):
        r"""
        render(SoSceneManager self, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        render(SoSceneManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        """
        return _coin.SoSceneManager_render(self, *args)

    def setCamera(self, camera):
        r"""setCamera(SoSceneManager self, SoCamera camera)"""
        return _coin.SoSceneManager_setCamera(self, camera)

    def getCamera(self):
        r"""getCamera(SoSceneManager self) -> SoCamera"""
        return _coin.SoSceneManager_getCamera(self)

    def processEvent(self, event):
        r"""processEvent(SoSceneManager self, SoEvent event) -> SbBool"""
        return _coin.SoSceneManager_processEvent(self, event)

    def reinitialize(self):
        r"""reinitialize(SoSceneManager self)"""
        return _coin.SoSceneManager_reinitialize(self)

    def scheduleRedraw(self):
        r"""scheduleRedraw(SoSceneManager self)"""
        return _coin.SoSceneManager_scheduleRedraw(self)

    def setSceneGraph(self, sceneroot):
        r"""setSceneGraph(SoSceneManager self, SoNode sceneroot)"""
        return _coin.SoSceneManager_setSceneGraph(self, sceneroot)

    def getSceneGraph(self):
        r"""getSceneGraph(SoSceneManager self) -> SoNode"""
        return _coin.SoSceneManager_getSceneGraph(self)

    def setWindowSize(self, newsize):
        r"""setWindowSize(SoSceneManager self, SbVec2s newsize)"""
        return _coin.SoSceneManager_setWindowSize(self, newsize)

    def getWindowSize(self):
        r"""getWindowSize(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getWindowSize(self)

    def setSize(self, newsize):
        r"""setSize(SoSceneManager self, SbVec2s newsize)"""
        return _coin.SoSceneManager_setSize(self, newsize)

    def getSize(self):
        r"""getSize(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getSize(self)

    def setOrigin(self, newOrigin):
        r"""setOrigin(SoSceneManager self, SbVec2s newOrigin)"""
        return _coin.SoSceneManager_setOrigin(self, newOrigin)

    def getOrigin(self):
        r"""getOrigin(SoSceneManager self) -> SbVec2s"""
        return _coin.SoSceneManager_getOrigin(self)

    def setViewportRegion(self, newRegion):
        r"""setViewportRegion(SoSceneManager self, SbViewportRegion newRegion)"""
        return _coin.SoSceneManager_setViewportRegion(self, newRegion)

    def getViewportRegion(self):
        r"""getViewportRegion(SoSceneManager self) -> SbViewportRegion"""
        return _coin.SoSceneManager_getViewportRegion(self)

    def setBackgroundColor(self, color):
        r"""setBackgroundColor(SoSceneManager self, SbColor color)"""
        return _coin.SoSceneManager_setBackgroundColor(self, color)

    def getBackgroundColor(self):
        r"""getBackgroundColor(SoSceneManager self) -> SbColor"""
        return _coin.SoSceneManager_getBackgroundColor(self)

    def setBackgroundIndex(self, index):
        r"""setBackgroundIndex(SoSceneManager self, int const index)"""
        return _coin.SoSceneManager_setBackgroundIndex(self, index)

    def getBackgroundIndex(self):
        r"""getBackgroundIndex(SoSceneManager self) -> int"""
        return _coin.SoSceneManager_getBackgroundIndex(self)

    def setRGBMode(self, onOrOff):
        r"""setRGBMode(SoSceneManager self, SbBool const onOrOff)"""
        return _coin.SoSceneManager_setRGBMode(self, onOrOff)

    def isRGBMode(self):
        r"""isRGBMode(SoSceneManager self) -> SbBool"""
        return _coin.SoSceneManager_isRGBMode(self)

    def activate(self):
        r"""activate(SoSceneManager self)"""
        return _coin.SoSceneManager_activate(self)

    def deactivate(self):
        r"""deactivate(SoSceneManager self)"""
        return _coin.SoSceneManager_deactivate(self)

    def isAutoRedraw(self):
        r"""isAutoRedraw(SoSceneManager self) -> SbBool"""
        return _coin.SoSceneManager_isAutoRedraw(self)

    def setRedrawPriority(self, priority):
        r"""setRedrawPriority(SoSceneManager self, uint32_t const priority)"""
        return _coin.SoSceneManager_setRedrawPriority(self, priority)

    def getRedrawPriority(self):
        r"""getRedrawPriority(SoSceneManager self) -> uint32_t"""
        return _coin.SoSceneManager_getRedrawPriority(self)

    def setAntialiasing(self, smoothing, numPasses):
        r"""setAntialiasing(SoSceneManager self, SbBool const smoothing, int const numPasses)"""
        return _coin.SoSceneManager_setAntialiasing(self, smoothing, numPasses)

    def getAntialiasing(self, smoothing, numPasses):
        r"""getAntialiasing(SoSceneManager self, SbBool & smoothing, int & numPasses)"""
        return _coin.SoSceneManager_getAntialiasing(self, smoothing, numPasses)

    def setGLRenderAction(self, action):
        r"""setGLRenderAction(SoSceneManager self, SoGLRenderAction action)"""
        return _coin.SoSceneManager_setGLRenderAction(self, action)

    def getGLRenderAction(self):
        r"""getGLRenderAction(SoSceneManager self) -> SoGLRenderAction"""
        return _coin.SoSceneManager_getGLRenderAction(self)

    def setAudioRenderAction(self, action):
        r"""setAudioRenderAction(SoSceneManager self, SoAudioRenderAction action)"""
        return _coin.SoSceneManager_setAudioRenderAction(self, action)

    def getAudioRenderAction(self):
        r"""getAudioRenderAction(SoSceneManager self) -> SoAudioRenderAction"""
        return _coin.SoSceneManager_getAudioRenderAction(self)

    def setHandleEventAction(self, hea):
        r"""setHandleEventAction(SoSceneManager self, SoHandleEventAction hea)"""
        return _coin.SoSceneManager_setHandleEventAction(self, hea)

    def getHandleEventAction(self):
        r"""getHandleEventAction(SoSceneManager self) -> SoHandleEventAction"""
        return _coin.SoSceneManager_getHandleEventAction(self)

    @staticmethod
    def getDefaultRedrawPriority():
        r"""getDefaultRedrawPriority() -> uint32_t"""
        return _coin.SoSceneManager_getDefaultRedrawPriority()

    @staticmethod
    def enableRealTimeUpdate(flag):
        r"""enableRealTimeUpdate(SbBool const flag)"""
        return _coin.SoSceneManager_enableRealTimeUpdate(flag)

    @staticmethod
    def isRealTimeUpdateEnabled():
        r"""isRealTimeUpdateEnabled() -> SbBool"""
        return _coin.SoSceneManager_isRealTimeUpdateEnabled()

    def setRenderCallback(self, *args):
        r"""
        setRenderCallback(SoSceneManager self, SoSceneManagerRenderCB * f, void *const userData=None)
        setRenderCallback(SoSceneManager self, PyObject * pyfunc, PyObject * userData=None)
        """
        return _coin.SoSceneManager_setRenderCallback(self, *args)

# Register SoSceneManager in _coin:
_coin.SoSceneManager_swigregister(SoSceneManager)
GL_GLEXT_PROTOTYPES = _coin.GL_GLEXT_PROTOTYPES

GL_CLAMP_TO_EDGE = _coin.GL_CLAMP_TO_EDGE

GL_CLAMP_TO_BORDER = _coin.GL_CLAMP_TO_BORDER

GL_REPLACE = _coin.GL_REPLACE

GL_MAX_3D_TEXTURE_SIZE = _coin.GL_MAX_3D_TEXTURE_SIZE

GL_PACK_IMAGE_HEIGHT = _coin.GL_PACK_IMAGE_HEIGHT

GL_PACK_SKIP_IMAGES = _coin.GL_PACK_SKIP_IMAGES

GL_PROXY_TEXTURE_2D = _coin.GL_PROXY_TEXTURE_2D

GL_PROXY_TEXTURE_3D = _coin.GL_PROXY_TEXTURE_3D

GL_TEXTURE_3D = _coin.GL_TEXTURE_3D

GL_TEXTURE_DEPTH = _coin.GL_TEXTURE_DEPTH

GL_TEXTURE_WRAP_R = _coin.GL_TEXTURE_WRAP_R

GL_UNPACK_IMAGE_HEIGHT = _coin.GL_UNPACK_IMAGE_HEIGHT

GL_UNPACK_SKIP_IMAGES = _coin.GL_UNPACK_SKIP_IMAGES

GL_COLOR_TABLE_WIDTH = _coin.GL_COLOR_TABLE_WIDTH

GL_TEXTURE0 = _coin.GL_TEXTURE0

GL_TEXTURE1 = _coin.GL_TEXTURE1

GL_TEXTURE2 = _coin.GL_TEXTURE2

GL_TEXTURE3 = _coin.GL_TEXTURE3

GL_TEXTURE4 = _coin.GL_TEXTURE4

GL_TEXTURE5 = _coin.GL_TEXTURE5

GL_TEXTURE6 = _coin.GL_TEXTURE6

GL_TEXTURE7 = _coin.GL_TEXTURE7

GL_TEXTURE8 = _coin.GL_TEXTURE8

GL_TEXTURE9 = _coin.GL_TEXTURE9

GL_TEXTURE10 = _coin.GL_TEXTURE10

GL_TEXTURE11 = _coin.GL_TEXTURE11

GL_TEXTURE12 = _coin.GL_TEXTURE12

GL_TEXTURE13 = _coin.GL_TEXTURE13

GL_TEXTURE14 = _coin.GL_TEXTURE14

GL_TEXTURE15 = _coin.GL_TEXTURE15

GL_MAX_TEXTURE_UNITS = _coin.GL_MAX_TEXTURE_UNITS

GL_ACTIVE_TEXTURE = _coin.GL_ACTIVE_TEXTURE

GL_CLIENT_ACTIVE_TEXTURE = _coin.GL_CLIENT_ACTIVE_TEXTURE

GL_POLYGON_OFFSET_EXT = _coin.GL_POLYGON_OFFSET_EXT

GL_COLOR_TABLE = _coin.GL_COLOR_TABLE

GL_COLOR_INDEX1_EXT = _coin.GL_COLOR_INDEX1_EXT

GL_COLOR_INDEX2_EXT = _coin.GL_COLOR_INDEX2_EXT

GL_COLOR_INDEX4_EXT = _coin.GL_COLOR_INDEX4_EXT

GL_COLOR_INDEX8_EXT = _coin.GL_COLOR_INDEX8_EXT

GL_COLOR_INDEX12_EXT = _coin.GL_COLOR_INDEX12_EXT

GL_COLOR_INDEX16_EXT = _coin.GL_COLOR_INDEX16_EXT

GL_COLOR_TABLE_FORMAT_EXT = _coin.GL_COLOR_TABLE_FORMAT_EXT

GL_COLOR_TABLE_RED_SIZE_EXT = _coin.GL_COLOR_TABLE_RED_SIZE_EXT

GL_COLOR_TABLE_GREEN_SIZE_EXT = _coin.GL_COLOR_TABLE_GREEN_SIZE_EXT

GL_COLOR_TABLE_BLUE_SIZE_EXT = _coin.GL_COLOR_TABLE_BLUE_SIZE_EXT

GL_COLOR_TABLE_ALPHA_SIZE_EXT = _coin.GL_COLOR_TABLE_ALPHA_SIZE_EXT

GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = _coin.GL_COLOR_TABLE_LUMINANCE_SIZE_EXT

GL_COLOR_TABLE_INTENSITY_SIZE_EXT = _coin.GL_COLOR_TABLE_INTENSITY_SIZE_EXT

GL_TEXTURE_INDEX_SIZE_EXT = _coin.GL_TEXTURE_INDEX_SIZE_EXT

GL_COMPRESSED_ALPHA_ARB = _coin.GL_COMPRESSED_ALPHA_ARB

GL_COMPRESSED_LUMINANCE_ARB = _coin.GL_COMPRESSED_LUMINANCE_ARB

GL_COMPRESSED_LUMINANCE_ALPHA_ARB = _coin.GL_COMPRESSED_LUMINANCE_ALPHA_ARB

GL_COMPRESSED_INTENSITY_ARB = _coin.GL_COMPRESSED_INTENSITY_ARB

GL_COMPRESSED_RGB_ARB = _coin.GL_COMPRESSED_RGB_ARB

GL_COMPRESSED_RGBA_ARB = _coin.GL_COMPRESSED_RGBA_ARB

GL_TEXTURE_COMPRESSION_HINT_ARB = _coin.GL_TEXTURE_COMPRESSION_HINT_ARB

GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = _coin.GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB

GL_TEXTURE_COMPRESSED_ARB = _coin.GL_TEXTURE_COMPRESSED_ARB

GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = _coin.GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB

GL_COMPRESSED_TEXTURE_FORMATS_ARB = _coin.GL_COMPRESSED_TEXTURE_FORMATS_ARB

GL_DEPTH_COMPONENT16 = _coin.GL_DEPTH_COMPONENT16

GL_DEPTH_COMPONENT24 = _coin.GL_DEPTH_COMPONENT24

GL_DEPTH_COMPONENT32 = _coin.GL_DEPTH_COMPONENT32

GL_TEXTURE_DEPTH_SIZE = _coin.GL_TEXTURE_DEPTH_SIZE

GL_DEPTH_TEXTURE_MODE = _coin.GL_DEPTH_TEXTURE_MODE

GL_R3_G3_B2 = _coin.GL_R3_G3_B2

GL_RGB4 = _coin.GL_RGB4

GL_RGB5 = _coin.GL_RGB5

GL_RGB8 = _coin.GL_RGB8

GL_RGB10 = _coin.GL_RGB10

GL_RGB12 = _coin.GL_RGB12

GL_RGB16 = _coin.GL_RGB16

GL_RGBA2 = _coin.GL_RGBA2

GL_RGBA4 = _coin.GL_RGBA4

GL_RGB5_A1 = _coin.GL_RGB5_A1

GL_RGBA8 = _coin.GL_RGBA8

GL_RGB10_A2 = _coin.GL_RGB10_A2

GL_RGBA12 = _coin.GL_RGBA12

GL_RGBA16 = _coin.GL_RGBA16

GL_RGBA32F_ARB = _coin.GL_RGBA32F_ARB

GL_RGB32F_ARB = _coin.GL_RGB32F_ARB

GL_ALPHA32F_ARB = _coin.GL_ALPHA32F_ARB

GL_INTENSITY32F_ARB = _coin.GL_INTENSITY32F_ARB

GL_LUMINANCE32F_ARB = _coin.GL_LUMINANCE32F_ARB

GL_LUMINANCE_ALPHA32F_ARB = _coin.GL_LUMINANCE_ALPHA32F_ARB

GL_RGBA16F_ARB = _coin.GL_RGBA16F_ARB

GL_RGB16F_ARB = _coin.GL_RGB16F_ARB

GL_ALPHA16F_ARB = _coin.GL_ALPHA16F_ARB

GL_INTENSITY16F_ARB = _coin.GL_INTENSITY16F_ARB

GL_LUMINANCE16F_ARB = _coin.GL_LUMINANCE16F_ARB

GL_LUMINANCE_ALPHA16F_ARB = _coin.GL_LUMINANCE_ALPHA16F_ARB

GL_RGBA16_EXT = _coin.GL_RGBA16_EXT

GL_TEXTURE_COMPARE_MODE = _coin.GL_TEXTURE_COMPARE_MODE

GL_TEXTURE_COMPARE_FUNC = _coin.GL_TEXTURE_COMPARE_FUNC

GL_COMPARE_R_TO_TEXTURE = _coin.GL_COMPARE_R_TO_TEXTURE

GL_MIN = _coin.GL_MIN

GL_MAX = _coin.GL_MAX

GL_FUNC_ADD = _coin.GL_FUNC_ADD

GL_FUNC_SUBTRACT = _coin.GL_FUNC_SUBTRACT

GL_FUNC_REVERSE_SUBTRACT = _coin.GL_FUNC_REVERSE_SUBTRACT

GL_VERTEX_ARRAY = _coin.GL_VERTEX_ARRAY

GL_NORMAL_ARRAY = _coin.GL_NORMAL_ARRAY

GL_COLOR_ARRAY = _coin.GL_COLOR_ARRAY

GL_INDEX_ARRAY = _coin.GL_INDEX_ARRAY

GL_TEXTURE_COORD_ARRAY = _coin.GL_TEXTURE_COORD_ARRAY

GL_V3F = _coin.GL_V3F

GL_C4UB_V3F = _coin.GL_C4UB_V3F

GL_C3F_V3F = _coin.GL_C3F_V3F

GL_N3F_V3F = _coin.GL_N3F_V3F

GL_C4F_N3F_V3F = _coin.GL_C4F_N3F_V3F

GL_T2F_V3F = _coin.GL_T2F_V3F

GL_T2F_C4UB_V3F = _coin.GL_T2F_C4UB_V3F

GL_T2F_C3F_V3F = _coin.GL_T2F_C3F_V3F

GL_T2F_N3F_V3F = _coin.GL_T2F_N3F_V3F

GL_T2F_C4F_N3F_V3F = _coin.GL_T2F_C4F_N3F_V3F

GL_VERTEX_ARRAY_RANGE_NV = _coin.GL_VERTEX_ARRAY_RANGE_NV

GL_VERTEX_ARRAY_RANGE_LENGTH_NV = _coin.GL_VERTEX_ARRAY_RANGE_LENGTH_NV

GL_VERTEX_ARRAY_RANGE_VALID_NV = _coin.GL_VERTEX_ARRAY_RANGE_VALID_NV

GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = _coin.GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV

GL_VERTEX_ARRAY_RANGE_POINTER_NV = _coin.GL_VERTEX_ARRAY_RANGE_POINTER_NV

GL_ARRAY_BUFFER = _coin.GL_ARRAY_BUFFER

GL_ELEMENT_ARRAY_BUFFER = _coin.GL_ELEMENT_ARRAY_BUFFER

GL_READ_ONLY = _coin.GL_READ_ONLY

GL_WRITE_ONLY = _coin.GL_WRITE_ONLY

GL_READ_WRITE = _coin.GL_READ_WRITE

GL_BUFFER_ACCESS = _coin.GL_BUFFER_ACCESS

GL_BUFFER_MAPPED = _coin.GL_BUFFER_MAPPED

GL_BUFFER_MAP_POINTER = _coin.GL_BUFFER_MAP_POINTER

GL_STREAM_DRAW = _coin.GL_STREAM_DRAW

GL_STREAM_READ = _coin.GL_STREAM_READ

GL_STREAM_COPY = _coin.GL_STREAM_COPY

GL_STATIC_DRAW = _coin.GL_STATIC_DRAW

GL_STATIC_READ = _coin.GL_STATIC_READ

GL_STATIC_COPY = _coin.GL_STATIC_COPY

GL_DYNAMIC_DRAW = _coin.GL_DYNAMIC_DRAW

GL_DYNAMIC_READ = _coin.GL_DYNAMIC_READ

GL_DYNAMIC_COPY = _coin.GL_DYNAMIC_COPY

GL_REGISTER_COMBINERS_NV = _coin.GL_REGISTER_COMBINERS_NV

GL_COMBINER0_NV = _coin.GL_COMBINER0_NV

GL_COMBINER1_NV = _coin.GL_COMBINER1_NV

GL_COMBINER2_NV = _coin.GL_COMBINER2_NV

GL_COMBINER3_NV = _coin.GL_COMBINER3_NV

GL_COMBINER4_NV = _coin.GL_COMBINER4_NV

GL_COMBINER5_NV = _coin.GL_COMBINER5_NV

GL_COMBINER6_NV = _coin.GL_COMBINER6_NV

GL_COMBINER7_NV = _coin.GL_COMBINER7_NV

GL_VARIABLE_A_NV = _coin.GL_VARIABLE_A_NV

GL_VARIABLE_B_NV = _coin.GL_VARIABLE_B_NV

GL_VARIABLE_C_NV = _coin.GL_VARIABLE_C_NV

GL_VARIABLE_D_NV = _coin.GL_VARIABLE_D_NV

GL_VARIABLE_E_NV = _coin.GL_VARIABLE_E_NV

GL_VARIABLE_F_NV = _coin.GL_VARIABLE_F_NV

GL_VARIABLE_G_NV = _coin.GL_VARIABLE_G_NV

GL_CONSTANT_COLOR0_NV = _coin.GL_CONSTANT_COLOR0_NV

GL_CONSTANT_COLOR1_NV = _coin.GL_CONSTANT_COLOR1_NV

GL_PRIMARY_COLOR_NV = _coin.GL_PRIMARY_COLOR_NV

GL_SECONDARY_COLOR_NV = _coin.GL_SECONDARY_COLOR_NV

GL_SPARE0_NV = _coin.GL_SPARE0_NV

GL_SPARE1_NV = _coin.GL_SPARE1_NV

GL_UNSIGNED_IDENTITY_NV = _coin.GL_UNSIGNED_IDENTITY_NV

GL_UNSIGNED_INVERT_NV = _coin.GL_UNSIGNED_INVERT_NV

GL_EXPAND_NORMAL_NV = _coin.GL_EXPAND_NORMAL_NV

GL_EXPAND_NEGATE_NV = _coin.GL_EXPAND_NEGATE_NV

GL_HALF_BIAS_NORMAL_NV = _coin.GL_HALF_BIAS_NORMAL_NV

GL_HALF_BIAS_NEGATE_NV = _coin.GL_HALF_BIAS_NEGATE_NV

GL_SIGNED_IDENTITY_NV = _coin.GL_SIGNED_IDENTITY_NV

GL_SIGNED_NEGATE_NV = _coin.GL_SIGNED_NEGATE_NV

GL_E_TIMES_F_NV = _coin.GL_E_TIMES_F_NV

GL_SPARE0_PLUS_SECONDARY_COLOR_NV = _coin.GL_SPARE0_PLUS_SECONDARY_COLOR_NV

GL_SCALE_BY_TWO_NV = _coin.GL_SCALE_BY_TWO_NV

GL_SCALE_BY_FOUR_NV = _coin.GL_SCALE_BY_FOUR_NV

GL_SCALE_BY_ONE_HALF_NV = _coin.GL_SCALE_BY_ONE_HALF_NV

GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = _coin.GL_BIAS_BY_NEGATIVE_ONE_HALF_NV

GL_DISCARD_NV = _coin.GL_DISCARD_NV

GL_COMBINER_INPUT_NV = _coin.GL_COMBINER_INPUT_NV

GL_COMBINER_MAPPING_NV = _coin.GL_COMBINER_MAPPING_NV

GL_COMBINER_COMPONENT_USAGE_NV = _coin.GL_COMBINER_COMPONENT_USAGE_NV

GL_COMBINER_AB_DOT_PRODUCT_NV = _coin.GL_COMBINER_AB_DOT_PRODUCT_NV

GL_COMBINER_CD_DOT_PRODUCT_NV = _coin.GL_COMBINER_CD_DOT_PRODUCT_NV

GL_COMBINER_MUX_SUM_NV = _coin.GL_COMBINER_MUX_SUM_NV

GL_COMBINER_SCALE_NV = _coin.GL_COMBINER_SCALE_NV

GL_COMBINER_BIAS_NV = _coin.GL_COMBINER_BIAS_NV

GL_COMBINER_AB_OUTPUT_NV = _coin.GL_COMBINER_AB_OUTPUT_NV

GL_COMBINER_CD_OUTPUT_NV = _coin.GL_COMBINER_CD_OUTPUT_NV

GL_COMBINER_SUM_OUTPUT_NV = _coin.GL_COMBINER_SUM_OUTPUT_NV

GL_MAX_GENERAL_COMBINERS_NV = _coin.GL_MAX_GENERAL_COMBINERS_NV

GL_NUM_GENERAL_COMBINERS_NV = _coin.GL_NUM_GENERAL_COMBINERS_NV

GL_COLOR_SUM_CLAMP_NV = _coin.GL_COLOR_SUM_CLAMP_NV

GL_TEXTURE_RECTANGLE_NV = _coin.GL_TEXTURE_RECTANGLE_NV

GL_TEXTURE_BINDING_RECTANGLE_NV = _coin.GL_TEXTURE_BINDING_RECTANGLE_NV

GL_PROXY_TEXTURE_RECTANGLE_NV = _coin.GL_PROXY_TEXTURE_RECTANGLE_NV

GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = _coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_NV

GL_TEXTURE_RECTANGLE_EXT = _coin.GL_TEXTURE_RECTANGLE_EXT

GL_TEXTURE_BINDING_RECTANGLE_EXT = _coin.GL_TEXTURE_BINDING_RECTANGLE_EXT

GL_PROXY_TEXTURE_RECTANGLE_EXT = _coin.GL_PROXY_TEXTURE_RECTANGLE_EXT

GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = _coin.GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT

GL_OFFSET_TEXTURE_RECTANGLE_NV = _coin.GL_OFFSET_TEXTURE_RECTANGLE_NV

GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = _coin.GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV

GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = _coin.GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV

GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = _coin.GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV

GL_UNSIGNED_INT_S8_S8_8_8_NV = _coin.GL_UNSIGNED_INT_S8_S8_8_8_NV

GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = _coin.GL_UNSIGNED_INT_8_8_S8_S8_REV_NV

GL_DSDT_MAG_INTENSITY_NV = _coin.GL_DSDT_MAG_INTENSITY_NV

GL_SHADER_CONSISTENT_NV = _coin.GL_SHADER_CONSISTENT_NV

GL_TEXTURE_SHADER_NV = _coin.GL_TEXTURE_SHADER_NV

GL_SHADER_OPERATION_NV = _coin.GL_SHADER_OPERATION_NV

GL_CULL_MODES_NV = _coin.GL_CULL_MODES_NV

GL_OFFSET_TEXTURE_MATRIX_NV = _coin.GL_OFFSET_TEXTURE_MATRIX_NV

GL_OFFSET_TEXTURE_SCALE_NV = _coin.GL_OFFSET_TEXTURE_SCALE_NV

GL_OFFSET_TEXTURE_BIAS_NV = _coin.GL_OFFSET_TEXTURE_BIAS_NV

GL_OFFSET_TEXTURE_2D_MATRIX_NV = _coin.GL_OFFSET_TEXTURE_2D_MATRIX_NV

GL_OFFSET_TEXTURE_2D_SCALE_NV = _coin.GL_OFFSET_TEXTURE_2D_SCALE_NV

GL_OFFSET_TEXTURE_2D_BIAS_NV = _coin.GL_OFFSET_TEXTURE_2D_BIAS_NV

GL_PREVIOUS_TEXTURE_INPUT_NV = _coin.GL_PREVIOUS_TEXTURE_INPUT_NV

GL_CONST_EYE_NV = _coin.GL_CONST_EYE_NV

GL_PASS_THROUGH_NV = _coin.GL_PASS_THROUGH_NV

GL_CULL_FRAGMENT_NV = _coin.GL_CULL_FRAGMENT_NV

GL_OFFSET_TEXTURE_2D_NV = _coin.GL_OFFSET_TEXTURE_2D_NV

GL_DEPENDENT_AR_TEXTURE_2D_NV = _coin.GL_DEPENDENT_AR_TEXTURE_2D_NV

GL_DEPENDENT_GB_TEXTURE_2D_NV = _coin.GL_DEPENDENT_GB_TEXTURE_2D_NV

GL_DOT_PRODUCT_NV = _coin.GL_DOT_PRODUCT_NV

GL_DOT_PRODUCT_DEPTH_REPLACE_NV = _coin.GL_DOT_PRODUCT_DEPTH_REPLACE_NV

GL_DOT_PRODUCT_TEXTURE_2D_NV = _coin.GL_DOT_PRODUCT_TEXTURE_2D_NV

GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV

GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV

GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV

GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = _coin.GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV

GL_HILO_NV = _coin.GL_HILO_NV

GL_DSDT_NV = _coin.GL_DSDT_NV

GL_DSDT_MAG_NV = _coin.GL_DSDT_MAG_NV

GL_DSDT_MAG_VIB_NV = _coin.GL_DSDT_MAG_VIB_NV

GL_HILO16_NV = _coin.GL_HILO16_NV

GL_SIGNED_HILO_NV = _coin.GL_SIGNED_HILO_NV

GL_SIGNED_HILO16_NV = _coin.GL_SIGNED_HILO16_NV

GL_SIGNED_RGBA_NV = _coin.GL_SIGNED_RGBA_NV

GL_SIGNED_RGBA8_NV = _coin.GL_SIGNED_RGBA8_NV

GL_SIGNED_RGB_NV = _coin.GL_SIGNED_RGB_NV

GL_SIGNED_RGB8_NV = _coin.GL_SIGNED_RGB8_NV

GL_SIGNED_LUMINANCE_NV = _coin.GL_SIGNED_LUMINANCE_NV

GL_SIGNED_LUMINANCE8_NV = _coin.GL_SIGNED_LUMINANCE8_NV

GL_SIGNED_LUMINANCE_ALPHA_NV = _coin.GL_SIGNED_LUMINANCE_ALPHA_NV

GL_SIGNED_LUMINANCE8_ALPHA8_NV = _coin.GL_SIGNED_LUMINANCE8_ALPHA8_NV

GL_SIGNED_ALPHA_NV = _coin.GL_SIGNED_ALPHA_NV

GL_SIGNED_ALPHA8_NV = _coin.GL_SIGNED_ALPHA8_NV

GL_SIGNED_INTENSITY_NV = _coin.GL_SIGNED_INTENSITY_NV

GL_SIGNED_INTENSITY8_NV = _coin.GL_SIGNED_INTENSITY8_NV

GL_DSDT8_NV = _coin.GL_DSDT8_NV

GL_DSDT8_MAG8_NV = _coin.GL_DSDT8_MAG8_NV

GL_DSDT8_MAG8_INTENSITY8_NV = _coin.GL_DSDT8_MAG8_INTENSITY8_NV

GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = _coin.GL_SIGNED_RGB_UNSIGNED_ALPHA_NV

GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = _coin.GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV

GL_HI_SCALE_NV = _coin.GL_HI_SCALE_NV

GL_LO_SCALE_NV = _coin.GL_LO_SCALE_NV

GL_DS_SCALE_NV = _coin.GL_DS_SCALE_NV

GL_DT_SCALE_NV = _coin.GL_DT_SCALE_NV

GL_MAGNITUDE_SCALE_NV = _coin.GL_MAGNITUDE_SCALE_NV

GL_VIBRANCE_SCALE_NV = _coin.GL_VIBRANCE_SCALE_NV

GL_HI_BIAS_NV = _coin.GL_HI_BIAS_NV

GL_LO_BIAS_NV = _coin.GL_LO_BIAS_NV

GL_DS_BIAS_NV = _coin.GL_DS_BIAS_NV

GL_DT_BIAS_NV = _coin.GL_DT_BIAS_NV

GL_MAGNITUDE_BIAS_NV = _coin.GL_MAGNITUDE_BIAS_NV

GL_VIBRANCE_BIAS_NV = _coin.GL_VIBRANCE_BIAS_NV

GL_TEXTURE_BORDER_VALUES_NV = _coin.GL_TEXTURE_BORDER_VALUES_NV

GL_TEXTURE_HI_SIZE_NV = _coin.GL_TEXTURE_HI_SIZE_NV

GL_TEXTURE_LO_SIZE_NV = _coin.GL_TEXTURE_LO_SIZE_NV

GL_TEXTURE_DS_SIZE_NV = _coin.GL_TEXTURE_DS_SIZE_NV

GL_TEXTURE_DT_SIZE_NV = _coin.GL_TEXTURE_DT_SIZE_NV

GL_TEXTURE_MAG_SIZE_NV = _coin.GL_TEXTURE_MAG_SIZE_NV

GL_NORMAL_MAP = _coin.GL_NORMAL_MAP

GL_REFLECTION_MAP = _coin.GL_REFLECTION_MAP

GL_TEXTURE_CUBE_MAP = _coin.GL_TEXTURE_CUBE_MAP

GL_TEXTURE_BINDING_CUBE_MAP = _coin.GL_TEXTURE_BINDING_CUBE_MAP

GL_TEXTURE_CUBE_MAP_POSITIVE_X = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_X

GL_TEXTURE_CUBE_MAP_NEGATIVE_X = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_X

GL_TEXTURE_CUBE_MAP_POSITIVE_Y = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Y

GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y

GL_TEXTURE_CUBE_MAP_POSITIVE_Z = _coin.GL_TEXTURE_CUBE_MAP_POSITIVE_Z

GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = _coin.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z

GL_MAX_CUBE_MAP_TEXTURE_SIZE = _coin.GL_MAX_CUBE_MAP_TEXTURE_SIZE

GL_COMBINE = _coin.GL_COMBINE

GL_COMBINE_RGB = _coin.GL_COMBINE_RGB

GL_COMBINE_ALPHA = _coin.GL_COMBINE_ALPHA

GL_RGB_SCALE = _coin.GL_RGB_SCALE

GL_ADD_SIGNED = _coin.GL_ADD_SIGNED

GL_INTERPOLATE = _coin.GL_INTERPOLATE

GL_CONSTANT = _coin.GL_CONSTANT

GL_PRIMARY_COLOR = _coin.GL_PRIMARY_COLOR

GL_PREVIOUS = _coin.GL_PREVIOUS

GL_SOURCE0_RGB = _coin.GL_SOURCE0_RGB

GL_SOURCE1_RGB = _coin.GL_SOURCE1_RGB

GL_SOURCE2_RGB = _coin.GL_SOURCE2_RGB

GL_SOURCE0_ALPHA = _coin.GL_SOURCE0_ALPHA

GL_SOURCE1_ALPHA = _coin.GL_SOURCE1_ALPHA

GL_SOURCE2_ALPHA = _coin.GL_SOURCE2_ALPHA

GL_OPERAND0_RGB = _coin.GL_OPERAND0_RGB

GL_OPERAND1_RGB = _coin.GL_OPERAND1_RGB

GL_OPERAND2_RGB = _coin.GL_OPERAND2_RGB

GL_OPERAND0_ALPHA = _coin.GL_OPERAND0_ALPHA

GL_OPERAND1_ALPHA = _coin.GL_OPERAND1_ALPHA

GL_OPERAND2_ALPHA = _coin.GL_OPERAND2_ALPHA

GL_SUBTRACT = _coin.GL_SUBTRACT

GL_DOT3_RGB = _coin.GL_DOT3_RGB

GL_DOT3_RGBA = _coin.GL_DOT3_RGBA

GL_GENERATE_MIPMAP_SGIS = _coin.GL_GENERATE_MIPMAP_SGIS

GL_GENERATE_MIPMAP_HINT_SGIS = _coin.GL_GENERATE_MIPMAP_HINT_SGIS

GL_FRAGMENT_PROGRAM_ARB = _coin.GL_FRAGMENT_PROGRAM_ARB

GL_PROGRAM_FORMAT_ASCII_ARB = _coin.GL_PROGRAM_FORMAT_ASCII_ARB

GL_PROGRAM_LENGTH_ARB = _coin.GL_PROGRAM_LENGTH_ARB

GL_PROGRAM_FORMAT_ARB = _coin.GL_PROGRAM_FORMAT_ARB

GL_PROGRAM_BINDING_ARB = _coin.GL_PROGRAM_BINDING_ARB

GL_PROGRAM_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_INSTRUCTIONS_ARB

GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB

GL_PROGRAM_TEMPORARIES_ARB = _coin.GL_PROGRAM_TEMPORARIES_ARB

GL_MAX_PROGRAM_TEMPORARIES_ARB = _coin.GL_MAX_PROGRAM_TEMPORARIES_ARB

GL_PROGRAM_NATIVE_TEMPORARIES_ARB = _coin.GL_PROGRAM_NATIVE_TEMPORARIES_ARB

GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB

GL_PROGRAM_PARAMETERS_ARB = _coin.GL_PROGRAM_PARAMETERS_ARB

GL_MAX_PROGRAM_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_PARAMETERS_ARB

GL_PROGRAM_NATIVE_PARAMETERS_ARB = _coin.GL_PROGRAM_NATIVE_PARAMETERS_ARB

GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB

GL_PROGRAM_ATTRIBS_ARB = _coin.GL_PROGRAM_ATTRIBS_ARB

GL_MAX_PROGRAM_ATTRIBS_ARB = _coin.GL_MAX_PROGRAM_ATTRIBS_ARB

GL_PROGRAM_NATIVE_ATTRIBS_ARB = _coin.GL_PROGRAM_NATIVE_ATTRIBS_ARB

GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB

GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB

GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = _coin.GL_MAX_PROGRAM_ENV_PARAMETERS_ARB

GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = _coin.GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB

GL_PROGRAM_ALU_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_ALU_INSTRUCTIONS_ARB

GL_PROGRAM_TEX_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_TEX_INSTRUCTIONS_ARB

GL_PROGRAM_TEX_INDIRECTIONS_ARB = _coin.GL_PROGRAM_TEX_INDIRECTIONS_ARB

GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB

GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = _coin.GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB

GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = _coin.GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB

GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = _coin.GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB

GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB

GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB

GL_PROGRAM_STRING_ARB = _coin.GL_PROGRAM_STRING_ARB

GL_PROGRAM_ERROR_POSITION_ARB = _coin.GL_PROGRAM_ERROR_POSITION_ARB

GL_CURRENT_MATRIX_ARB = _coin.GL_CURRENT_MATRIX_ARB

GL_TRANSPOSE_CURRENT_MATRIX_ARB = _coin.GL_TRANSPOSE_CURRENT_MATRIX_ARB

GL_CURRENT_MATRIX_STACK_DEPTH_ARB = _coin.GL_CURRENT_MATRIX_STACK_DEPTH_ARB

GL_MAX_PROGRAM_MATRICES_ARB = _coin.GL_MAX_PROGRAM_MATRICES_ARB

GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = _coin.GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB

GL_MAX_TEXTURE_COORDS_ARB = _coin.GL_MAX_TEXTURE_COORDS_ARB

GL_MAX_TEXTURE_IMAGE_UNITS_ARB = _coin.GL_MAX_TEXTURE_IMAGE_UNITS_ARB

GL_PROGRAM_ERROR_STRING_ARB = _coin.GL_PROGRAM_ERROR_STRING_ARB

GL_MATRIX0_ARB = _coin.GL_MATRIX0_ARB

GL_MATRIX1_ARB = _coin.GL_MATRIX1_ARB

GL_MATRIX2_ARB = _coin.GL_MATRIX2_ARB

GL_MATRIX3_ARB = _coin.GL_MATRIX3_ARB

GL_MATRIX4_ARB = _coin.GL_MATRIX4_ARB

GL_MATRIX5_ARB = _coin.GL_MATRIX5_ARB

GL_MATRIX6_ARB = _coin.GL_MATRIX6_ARB

GL_MATRIX7_ARB = _coin.GL_MATRIX7_ARB

GL_MATRIX8_ARB = _coin.GL_MATRIX8_ARB

GL_MATRIX9_ARB = _coin.GL_MATRIX9_ARB

GL_MATRIX10_ARB = _coin.GL_MATRIX10_ARB

GL_MATRIX11_ARB = _coin.GL_MATRIX11_ARB

GL_MATRIX12_ARB = _coin.GL_MATRIX12_ARB

GL_MATRIX13_ARB = _coin.GL_MATRIX13_ARB

GL_MATRIX14_ARB = _coin.GL_MATRIX14_ARB

GL_MATRIX15_ARB = _coin.GL_MATRIX15_ARB

GL_MATRIX16_ARB = _coin.GL_MATRIX16_ARB

GL_MATRIX17_ARB = _coin.GL_MATRIX17_ARB

GL_MATRIX18_ARB = _coin.GL_MATRIX18_ARB

GL_MATRIX19_ARB = _coin.GL_MATRIX19_ARB

GL_MATRIX20_ARB = _coin.GL_MATRIX20_ARB

GL_MATRIX21_ARB = _coin.GL_MATRIX21_ARB

GL_MATRIX22_ARB = _coin.GL_MATRIX22_ARB

GL_MATRIX23_ARB = _coin.GL_MATRIX23_ARB

GL_MATRIX24_ARB = _coin.GL_MATRIX24_ARB

GL_MATRIX25_ARB = _coin.GL_MATRIX25_ARB

GL_MATRIX26_ARB = _coin.GL_MATRIX26_ARB

GL_MATRIX27_ARB = _coin.GL_MATRIX27_ARB

GL_MATRIX28_ARB = _coin.GL_MATRIX28_ARB

GL_MATRIX29_ARB = _coin.GL_MATRIX29_ARB

GL_MATRIX30_ARB = _coin.GL_MATRIX30_ARB

GL_MATRIX31_ARB = _coin.GL_MATRIX31_ARB

GL_VERTEX_PROGRAM_ARB = _coin.GL_VERTEX_PROGRAM_ARB

GL_VERTEX_PROGRAM_POINT_SIZE_ARB = _coin.GL_VERTEX_PROGRAM_POINT_SIZE_ARB

GL_VERTEX_PROGRAM_TWO_SIDE_ARB = _coin.GL_VERTEX_PROGRAM_TWO_SIDE_ARB

GL_COLOR_SUM_ARB = _coin.GL_COLOR_SUM_ARB

GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB

GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB

GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB

GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB

GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB

GL_CURRENT_VERTEX_ATTRIB_ARB = _coin.GL_CURRENT_VERTEX_ATTRIB_ARB

GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = _coin.GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB

GL_PROGRAM_ADDRESS_REGISTERS_ARB = _coin.GL_PROGRAM_ADDRESS_REGISTERS_ARB

GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = _coin.GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB

GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = _coin.GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB

GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = _coin.GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB

GL_MAX_VERTEX_ATTRIBS_ARB = _coin.GL_MAX_VERTEX_ATTRIBS_ARB

GL_VERTEX_SHADER_ARB = _coin.GL_VERTEX_SHADER_ARB

GL_FRAGMENT_SHADER_ARB = _coin.GL_FRAGMENT_SHADER_ARB

GL_OBJECT_ACTIVE_UNIFORMS_ARB = _coin.GL_OBJECT_ACTIVE_UNIFORMS_ARB

GL_GEOMETRY_SHADER_EXT = _coin.GL_GEOMETRY_SHADER_EXT

GL_GEOMETRY_VERTICES_OUT_EXT = _coin.GL_GEOMETRY_VERTICES_OUT_EXT

GL_GEOMETRY_INPUT_TYPE_EXT = _coin.GL_GEOMETRY_INPUT_TYPE_EXT

GL_GEOMETRY_OUTPUT_TYPE_EXT = _coin.GL_GEOMETRY_OUTPUT_TYPE_EXT

GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = _coin.GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT

GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT

GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = _coin.GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT

GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT

GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = _coin.GL_MAX_VERTEX_VARYING_COMPONENTS_EXT

GL_MAX_VARYING_COMPONENTS_EXT = _coin.GL_MAX_VARYING_COMPONENTS_EXT

GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = _coin.GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT

GL_INT_VEC2_ARB = _coin.GL_INT_VEC2_ARB

GL_INT_VEC3_ARB = _coin.GL_INT_VEC3_ARB

GL_INT_VEC4_ARB = _coin.GL_INT_VEC4_ARB

GL_FLOAT_VEC2_ARB = _coin.GL_FLOAT_VEC2_ARB

GL_FLOAT_VEC3_ARB = _coin.GL_FLOAT_VEC3_ARB

GL_FLOAT_VEC4_ARB = _coin.GL_FLOAT_VEC4_ARB

GL_FLOAT_MAT2_ARB = _coin.GL_FLOAT_MAT2_ARB

GL_FLOAT_MAT3_ARB = _coin.GL_FLOAT_MAT3_ARB

GL_FLOAT_MAT4_ARB = _coin.GL_FLOAT_MAT4_ARB

GL_SAMPLER_1D_ARB = _coin.GL_SAMPLER_1D_ARB

GL_SAMPLER_2D_ARB = _coin.GL_SAMPLER_2D_ARB

GL_SAMPLER_3D_ARB = _coin.GL_SAMPLER_3D_ARB

GL_SAMPLER_CUBE_ARB = _coin.GL_SAMPLER_CUBE_ARB

GL_SAMPLER_1D_SHADOW_ARB = _coin.GL_SAMPLER_1D_SHADOW_ARB

GL_SAMPLER_2D_SHADOW_ARB = _coin.GL_SAMPLER_2D_SHADOW_ARB

GL_SAMPLER_2D_RECT_ARB = _coin.GL_SAMPLER_2D_RECT_ARB

GL_SAMPLER_2D_RECT_SHADOW_ARB = _coin.GL_SAMPLER_2D_RECT_SHADOW_ARB

GL_OBJECT_COMPILE_STATUS_ARB = _coin.GL_OBJECT_COMPILE_STATUS_ARB

GL_OBJECT_INFO_LOG_LENGTH_ARB = _coin.GL_OBJECT_INFO_LOG_LENGTH_ARB

GL_OBJECT_LINK_STATUS_ARB = _coin.GL_OBJECT_LINK_STATUS_ARB

GL_TEXTURE_MAX_ANISOTROPY_EXT = _coin.GL_TEXTURE_MAX_ANISOTROPY_EXT

GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = _coin.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT

GL_SAMPLES_PASSED = _coin.GL_SAMPLES_PASSED

GL_QUERY_COUNTER_BITS = _coin.GL_QUERY_COUNTER_BITS

GL_CURRENT_QUERY = _coin.GL_CURRENT_QUERY

GL_QUERY_RESULT = _coin.GL_QUERY_RESULT

GL_QUERY_RESULT_AVAILABLE = _coin.GL_QUERY_RESULT_AVAILABLE

GL_CLIENT_PIXEL_STORE_BIT = _coin.GL_CLIENT_PIXEL_STORE_BIT

GL_CLIENT_VERTEX_ARRAY_BIT = _coin.GL_CLIENT_VERTEX_ARRAY_BIT

GL_CLIENT_ALL_ATTRIB_BITS = _coin.GL_CLIENT_ALL_ATTRIB_BITS

GL_ALL_CLIENT_ATTRIB_BITS = _coin.GL_ALL_CLIENT_ATTRIB_BITS

GL_INVALID_FRAMEBUFFER_OPERATION_EXT = _coin.GL_INVALID_FRAMEBUFFER_OPERATION_EXT

GL_MAX_RENDERBUFFER_SIZE_EXT = _coin.GL_MAX_RENDERBUFFER_SIZE_EXT

GL_FRAMEBUFFER_BINDING_EXT = _coin.GL_FRAMEBUFFER_BINDING_EXT

GL_RENDERBUFFER_BINDING_EXT = _coin.GL_RENDERBUFFER_BINDING_EXT

GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT

GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT

GL_FRAMEBUFFER_COMPLETE_EXT = _coin.GL_FRAMEBUFFER_COMPLETE_EXT

GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT

GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT

GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT

GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT

GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT

GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT

GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = _coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT

GL_FRAMEBUFFER_UNSUPPORTED_EXT = _coin.GL_FRAMEBUFFER_UNSUPPORTED_EXT

GL_MAX_COLOR_ATTACHMENTS_EXT = _coin.GL_MAX_COLOR_ATTACHMENTS_EXT

GL_COLOR_ATTACHMENT0_EXT = _coin.GL_COLOR_ATTACHMENT0_EXT

GL_COLOR_ATTACHMENT1_EXT = _coin.GL_COLOR_ATTACHMENT1_EXT

GL_COLOR_ATTACHMENT2_EXT = _coin.GL_COLOR_ATTACHMENT2_EXT

GL_COLOR_ATTACHMENT3_EXT = _coin.GL_COLOR_ATTACHMENT3_EXT

GL_COLOR_ATTACHMENT4_EXT = _coin.GL_COLOR_ATTACHMENT4_EXT

GL_COLOR_ATTACHMENT5_EXT = _coin.GL_COLOR_ATTACHMENT5_EXT

GL_COLOR_ATTACHMENT6_EXT = _coin.GL_COLOR_ATTACHMENT6_EXT

GL_COLOR_ATTACHMENT7_EXT = _coin.GL_COLOR_ATTACHMENT7_EXT

GL_COLOR_ATTACHMENT8_EXT = _coin.GL_COLOR_ATTACHMENT8_EXT

GL_COLOR_ATTACHMENT9_EXT = _coin.GL_COLOR_ATTACHMENT9_EXT

GL_COLOR_ATTACHMENT10_EXT = _coin.GL_COLOR_ATTACHMENT10_EXT

GL_COLOR_ATTACHMENT11_EXT = _coin.GL_COLOR_ATTACHMENT11_EXT

GL_COLOR_ATTACHMENT12_EXT = _coin.GL_COLOR_ATTACHMENT12_EXT

GL_COLOR_ATTACHMENT13_EXT = _coin.GL_COLOR_ATTACHMENT13_EXT

GL_COLOR_ATTACHMENT14_EXT = _coin.GL_COLOR_ATTACHMENT14_EXT

GL_COLOR_ATTACHMENT15_EXT = _coin.GL_COLOR_ATTACHMENT15_EXT

GL_DEPTH_ATTACHMENT_EXT = _coin.GL_DEPTH_ATTACHMENT_EXT

GL_STENCIL_ATTACHMENT_EXT = _coin.GL_STENCIL_ATTACHMENT_EXT

GL_FRAMEBUFFER_EXT = _coin.GL_FRAMEBUFFER_EXT

GL_RENDERBUFFER_EXT = _coin.GL_RENDERBUFFER_EXT

GL_RENDERBUFFER_WIDTH_EXT = _coin.GL_RENDERBUFFER_WIDTH_EXT

GL_RENDERBUFFER_HEIGHT_EXT = _coin.GL_RENDERBUFFER_HEIGHT_EXT

GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = _coin.GL_RENDERBUFFER_INTERNAL_FORMAT_EXT

GL_STENCIL_INDEX1_EXT = _coin.GL_STENCIL_INDEX1_EXT

GL_STENCIL_INDEX4_EXT = _coin.GL_STENCIL_INDEX4_EXT

GL_STENCIL_INDEX8_EXT = _coin.GL_STENCIL_INDEX8_EXT

GL_STENCIL_INDEX16_EXT = _coin.GL_STENCIL_INDEX16_EXT

GL_RENDERBUFFER_RED_SIZE_EXT = _coin.GL_RENDERBUFFER_RED_SIZE_EXT

GL_RENDERBUFFER_GREEN_SIZE_EXT = _coin.GL_RENDERBUFFER_GREEN_SIZE_EXT

GL_RENDERBUFFER_BLUE_SIZE_EXT = _coin.GL_RENDERBUFFER_BLUE_SIZE_EXT

GL_RENDERBUFFER_ALPHA_SIZE_EXT = _coin.GL_RENDERBUFFER_ALPHA_SIZE_EXT

GL_RENDERBUFFER_DEPTH_SIZE_EXT = _coin.GL_RENDERBUFFER_DEPTH_SIZE_EXT

GL_RENDERBUFFER_STENCIL_SIZE_EXT = _coin.GL_RENDERBUFFER_STENCIL_SIZE_EXT

GL_INVALID_FRAMEBUFFER_OPERATION = _coin.GL_INVALID_FRAMEBUFFER_OPERATION

GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = _coin.GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING

GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = _coin.GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE

GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE

GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE

GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE

GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE

GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE

GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = _coin.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE

GL_DEPTH_STENCIL = _coin.GL_DEPTH_STENCIL

GL_UNSIGNED_INT_24_ = _coin.GL_UNSIGNED_INT_24_

GL_DEPTH24_STENCIL8 = _coin.GL_DEPTH24_STENCIL8

GL_TEXTURE_STENCIL_SIZE = _coin.GL_TEXTURE_STENCIL_SIZE

GL_SRGB = _coin.GL_SRGB

GL_UNSIGNED_NORMALIZED = _coin.GL_UNSIGNED_NORMALIZED

GL_FRAMEBUFFER_DEFAULT = _coin.GL_FRAMEBUFFER_DEFAULT

GL_FRAMEBUFFER_UNDEFINED = _coin.GL_FRAMEBUFFER_UNDEFINED

GL_DEPTH_STENCIL_ATTACHMENT = _coin.GL_DEPTH_STENCIL_ATTACHMENT

GL_INDEX = _coin.GL_INDEX

GL_MAX_RENDERBUFFER_SIZE = _coin.GL_MAX_RENDERBUFFER_SIZE

GL_FRAMEBUFFER_BINDING = _coin.GL_FRAMEBUFFER_BINDING

GL_DRAW_FRAMEBUFFER_BINDING = _coin.GL_DRAW_FRAMEBUFFER_BINDING

GL_RENDERBUFFER_BINDING = _coin.GL_RENDERBUFFER_BINDING

GL_READ_FRAMEBUFFER = _coin.GL_READ_FRAMEBUFFER

GL_DRAW_FRAMEBUFFER = _coin.GL_DRAW_FRAMEBUFFER

GL_READ_FRAMEBUFFER_BINDING = _coin.GL_READ_FRAMEBUFFER_BINDING

GL_RENDERBUFFER_SAMPLES = _coin.GL_RENDERBUFFER_SAMPLES

GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE

GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = _coin.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER

GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET = _coin.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET

GL_FRAMEBUFFER_COMPLETE = _coin.GL_FRAMEBUFFER_COMPLETE

GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT

GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT

GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT = _coin.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT

GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = _coin.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER

GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = _coin.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER

GL_FRAMEBUFFER_UNSUPPORTED = _coin.GL_FRAMEBUFFER_UNSUPPORTED

GL_MAX_COLOR_ATTACHMENTS = _coin.GL_MAX_COLOR_ATTACHMENTS

GL_COLOR_ATTACHMENT0 = _coin.GL_COLOR_ATTACHMENT0

GL_COLOR_ATTACHMENT1 = _coin.GL_COLOR_ATTACHMENT1

GL_COLOR_ATTACHMENT2 = _coin.GL_COLOR_ATTACHMENT2

GL_COLOR_ATTACHMENT3 = _coin.GL_COLOR_ATTACHMENT3

GL_COLOR_ATTACHMENT4 = _coin.GL_COLOR_ATTACHMENT4

GL_COLOR_ATTACHMENT5 = _coin.GL_COLOR_ATTACHMENT5

GL_COLOR_ATTACHMENT6 = _coin.GL_COLOR_ATTACHMENT6

GL_COLOR_ATTACHMENT7 = _coin.GL_COLOR_ATTACHMENT7

GL_COLOR_ATTACHMENT8 = _coin.GL_COLOR_ATTACHMENT8

GL_COLOR_ATTACHMENT9 = _coin.GL_COLOR_ATTACHMENT9

GL_COLOR_ATTACHMENT10 = _coin.GL_COLOR_ATTACHMENT10

GL_COLOR_ATTACHMENT11 = _coin.GL_COLOR_ATTACHMENT11

GL_COLOR_ATTACHMENT12 = _coin.GL_COLOR_ATTACHMENT12

GL_COLOR_ATTACHMENT13 = _coin.GL_COLOR_ATTACHMENT13

GL_COLOR_ATTACHMENT14 = _coin.GL_COLOR_ATTACHMENT14

GL_COLOR_ATTACHMENT15 = _coin.GL_COLOR_ATTACHMENT15

GL_DEPTH_ATTACHMENT = _coin.GL_DEPTH_ATTACHMENT

GL_STENCIL_ATTACHMENT = _coin.GL_STENCIL_ATTACHMENT

GL_FRAMEBUFFER = _coin.GL_FRAMEBUFFER

GL_RENDERBUFFER = _coin.GL_RENDERBUFFER

GL_RENDERBUFFER_WIDTH = _coin.GL_RENDERBUFFER_WIDTH

GL_RENDERBUFFER_HEIGHT = _coin.GL_RENDERBUFFER_HEIGHT

GL_RENDERBUFFER_INTERNAL_FORMAT = _coin.GL_RENDERBUFFER_INTERNAL_FORMAT

GL_STENCIL_INDEX1 = _coin.GL_STENCIL_INDEX1

GL_STENCIL_INDEX4 = _coin.GL_STENCIL_INDEX4

GL_STENCIL_INDEX8 = _coin.GL_STENCIL_INDEX8

GL_STENCIL_INDEX16 = _coin.GL_STENCIL_INDEX16

GL_RENDERBUFFER_RED_SIZE = _coin.GL_RENDERBUFFER_RED_SIZE

GL_RENDERBUFFER_GREEN_SIZE = _coin.GL_RENDERBUFFER_GREEN_SIZE

GL_RENDERBUFFER_BLUE_SIZE = _coin.GL_RENDERBUFFER_BLUE_SIZE

GL_RENDERBUFFER_ALPHA_SIZE = _coin.GL_RENDERBUFFER_ALPHA_SIZE

GL_RENDERBUFFER_DEPTH_SIZE = _coin.GL_RENDERBUFFER_DEPTH_SIZE

GL_RENDERBUFFER_STENCIL_SIZE = _coin.GL_RENDERBUFFER_STENCIL_SIZE

GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = _coin.GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE

GL_MAX_SAMPLES = _coin.GL_MAX_SAMPLES

GLX_PBUFFER_WIDTH = _coin.GLX_PBUFFER_WIDTH

GLX_PBUFFER_HEIGHT = _coin.GLX_PBUFFER_HEIGHT

GLX_DRAWABLE_TYPE = _coin.GLX_DRAWABLE_TYPE

GLX_RENDER_TYPE = _coin.GLX_RENDER_TYPE

GLX_RGBA_TYPE = _coin.GLX_RGBA_TYPE

GLX_RGBA_BIT = _coin.GLX_RGBA_BIT

GLX_PBUFFER_BIT = _coin.GLX_PBUFFER_BIT

GLX_MAX_PBUFFER_WIDTH = _coin.GLX_MAX_PBUFFER_WIDTH

GLX_MAX_PBUFFER_HEIGHT = _coin.GLX_MAX_PBUFFER_HEIGHT

GLX_MAX_PBUFFER_PIXELS = _coin.GLX_MAX_PBUFFER_PIXELS

GLU_VERSION = _coin.GLU_VERSION

GLU_EXTENSIONS = _coin.GLU_EXTENSIONS

GLU_OUTLINE_POLYGON = _coin.GLU_OUTLINE_POLYGON

GLU_OUTLINE_PATCH = _coin.GLU_OUTLINE_PATCH

GLU_NURBS_ERROR = _coin.GLU_NURBS_ERROR

GLU_ERROR = _coin.GLU_ERROR

GLU_NURBS_BEGIN = _coin.GLU_NURBS_BEGIN

GLU_NURBS_VERTEX = _coin.GLU_NURBS_VERTEX

GLU_NURBS_NORMAL = _coin.GLU_NURBS_NORMAL

GLU_NURBS_COLOR = _coin.GLU_NURBS_COLOR

GLU_NURBS_TEXTURE_COORD = _coin.GLU_NURBS_TEXTURE_COORD

GLU_NURBS_END = _coin.GLU_NURBS_END

GLU_NURBS_BEGIN_DATA = _coin.GLU_NURBS_BEGIN_DATA

GLU_NURBS_VERTEX_DATA = _coin.GLU_NURBS_VERTEX_DATA

GLU_NURBS_NORMAL_DATA = _coin.GLU_NURBS_NORMAL_DATA

GLU_NURBS_COLOR_DATA = _coin.GLU_NURBS_COLOR_DATA

GLU_NURBS_TEXTURE_COORD_DATA = _coin.GLU_NURBS_TEXTURE_COORD_DATA

GLU_NURBS_END_DATA = _coin.GLU_NURBS_END_DATA

GLU_AUTO_LOAD_MATRIX = _coin.GLU_AUTO_LOAD_MATRIX

GLU_CULLING = _coin.GLU_CULLING

GLU_SAMPLING_TOLERANCE = _coin.GLU_SAMPLING_TOLERANCE

GLU_DISPLAY_MODE = _coin.GLU_DISPLAY_MODE

GLU_PARAMETRIC_TOLERANCE = _coin.GLU_PARAMETRIC_TOLERANCE

GLU_SAMPLING_METHOD = _coin.GLU_SAMPLING_METHOD

GLU_U_STEP = _coin.GLU_U_STEP

GLU_V_STEP = _coin.GLU_V_STEP

GLU_NURBS_MODE = _coin.GLU_NURBS_MODE

GLU_NURBS_TESSELLATOR = _coin.GLU_NURBS_TESSELLATOR

GLU_NURBS_RENDERER = _coin.GLU_NURBS_RENDERER

GLU_OBJECT_PARAMETRIC_ERROR = _coin.GLU_OBJECT_PARAMETRIC_ERROR

GLU_OBJECT_PATH_LENGTH = _coin.GLU_OBJECT_PATH_LENGTH

GLU_PATH_LENGTH = _coin.GLU_PATH_LENGTH

GLU_PARAMETRIC_ERROR = _coin.GLU_PARAMETRIC_ERROR

GLU_DOMAIN_DISTANCE = _coin.GLU_DOMAIN_DISTANCE

GLU_MAP1_TRIM_2 = _coin.GLU_MAP1_TRIM_2

GLU_MAP1_TRIM_3 = _coin.GLU_MAP1_TRIM_3

GLU_POINT = _coin.GLU_POINT

GLU_LINE = _coin.GLU_LINE

GLU_FILL = _coin.GLU_FILL

GLU_SILHOUETTE = _coin.GLU_SILHOUETTE

GLU_TESS_BEGIN = _coin.GLU_TESS_BEGIN

GLU_TESS_VERTEX = _coin.GLU_TESS_VERTEX

GLU_TESS_END = _coin.GLU_TESS_END

GLU_TESS_ERROR = _coin.GLU_TESS_ERROR

GLU_TESS_COMBINE = _coin.GLU_TESS_COMBINE

GLU_TESS_BEGIN_DATA = _coin.GLU_TESS_BEGIN_DATA

GLU_TESS_VERTEX_DATA = _coin.GLU_TESS_VERTEX_DATA

GLU_TESS_END_DATA = _coin.GLU_TESS_END_DATA

GLU_TESS_ERROR_DATA = _coin.GLU_TESS_ERROR_DATA

GLU_TESS_MISSING_BEGIN_POLYGON = _coin.GLU_TESS_MISSING_BEGIN_POLYGON

GLU_TESS_MISSING_BEGIN_CONTOUR = _coin.GLU_TESS_MISSING_BEGIN_CONTOUR

GLU_TESS_MISSING_END_POLYGON = _coin.GLU_TESS_MISSING_END_POLYGON

GLU_TESS_MISSING_END_CONTOUR = _coin.GLU_TESS_MISSING_END_CONTOUR

GLU_TESS_NEED_COMBINE_CALLBACK = _coin.GLU_TESS_NEED_COMBINE_CALLBACK

WGL_COLOR_BITS_ARB = _coin.WGL_COLOR_BITS_ARB

WGL_ALPHA_BITS_ARB = _coin.WGL_ALPHA_BITS_ARB

WGL_DEPTH_BITS_ARB = _coin.WGL_DEPTH_BITS_ARB

WGL_STENCIL_BITS_ARB = _coin.WGL_STENCIL_BITS_ARB

WGL_DRAW_TO_PBUFFER_ARB = _coin.WGL_DRAW_TO_PBUFFER_ARB

WGL_PBUFFER_WIDTH_ARB = _coin.WGL_PBUFFER_WIDTH_ARB

WGL_PBUFFER_HEIGHT_ARB = _coin.WGL_PBUFFER_HEIGHT_ARB

WGL_BIND_TO_TEXTURE_RGB_ARB = _coin.WGL_BIND_TO_TEXTURE_RGB_ARB

WGL_BIND_TO_TEXTURE_RGBA_ARB = _coin.WGL_BIND_TO_TEXTURE_RGBA_ARB

WGL_TEXTURE_FORMAT_ARB = _coin.WGL_TEXTURE_FORMAT_ARB

WGL_TEXTURE_TARGET_ARB = _coin.WGL_TEXTURE_TARGET_ARB

WGL_MIPMAP_TEXTURE_ARB = _coin.WGL_MIPMAP_TEXTURE_ARB

WGL_TEXTURE_RGB_ARB = _coin.WGL_TEXTURE_RGB_ARB

WGL_TEXTURE_RGBA_ARB = _coin.WGL_TEXTURE_RGBA_ARB

WGL_NO_TEXTURE_ARB = _coin.WGL_NO_TEXTURE_ARB

WGL_TEXTURE_CUBE_MAP_ARB = _coin.WGL_TEXTURE_CUBE_MAP_ARB

WGL_TEXTURE_1D_ARB = _coin.WGL_TEXTURE_1D_ARB

WGL_TEXTURE_2D_ARB = _coin.WGL_TEXTURE_2D_ARB

WGL_MIPMAP_LEVEL_ARB = _coin.WGL_MIPMAP_LEVEL_ARB

WGL_FRONT_LEFT_ARB = _coin.WGL_FRONT_LEFT_ARB

WGL_FRONT_RIGHT_ARB = _coin.WGL_FRONT_RIGHT_ARB

WGL_BACK_LEFT_ARB = _coin.WGL_BACK_LEFT_ARB

WGL_BACK_RIGHT_ARB = _coin.WGL_BACK_RIGHT_ARB

WGL_MAX_PBUFFER_PIXELS_ARB = _coin.WGL_MAX_PBUFFER_PIXELS_ARB

WGL_MAX_PBUFFER_WIDTH_ARB = _coin.WGL_MAX_PBUFFER_WIDTH_ARB

WGL_MAX_PBUFFER_HEIGHT_ARB = _coin.WGL_MAX_PBUFFER_HEIGHT_ARB

class SbBarrier(object):
    r"""Proxy of C++ SbBarrier class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, count):
        r"""__init__(SbBarrier self, unsigned int count) -> SbBarrier"""
        _coin.SbBarrier_swiginit(self, _coin.new_SbBarrier(count))
    __swig_destroy__ = _coin.delete_SbBarrier

    def enter(self):
        r"""enter(SbBarrier self) -> int"""
        return _coin.SbBarrier_enter(self)

# Register SbBarrier in _coin:
_coin.SbBarrier_swigregister(SbBarrier)
class SbMutex(object):
    r"""Proxy of C++ SbMutex class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SbMutex self) -> SbMutex"""
        _coin.SbMutex_swiginit(self, _coin.new_SbMutex())
    __swig_destroy__ = _coin.delete_SbMutex

    def lock(self):
        r"""lock(SbMutex self) -> int"""
        return _coin.SbMutex_lock(self)

    def tryLock(self):
        r"""tryLock(SbMutex self) -> SbBool"""
        return _coin.SbMutex_tryLock(self)

    def unlock(self):
        r"""unlock(SbMutex self) -> int"""
        return _coin.SbMutex_unlock(self)

# Register SbMutex in _coin:
_coin.SbMutex_swigregister(SbMutex)
class SbThreadMutex(object):
    r"""Proxy of C++ SbThreadMutex class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SbThreadMutex self) -> SbThreadMutex"""
        _coin.SbThreadMutex_swiginit(self, _coin.new_SbThreadMutex())
    __swig_destroy__ = _coin.delete_SbThreadMutex

    def lock(self):
        r"""lock(SbThreadMutex self) -> int"""
        return _coin.SbThreadMutex_lock(self)

    def tryLock(self):
        r"""tryLock(SbThreadMutex self) -> SbBool"""
        return _coin.SbThreadMutex_tryLock(self)

    def unlock(self):
        r"""unlock(SbThreadMutex self) -> int"""
        return _coin.SbThreadMutex_unlock(self)

# Register SbThreadMutex in _coin:
_coin.SbThreadMutex_swigregister(SbThreadMutex)
class SbThreadAutoLock(object):
    r"""Proxy of C++ SbThreadAutoLock class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbThreadAutoLock self, SbMutex mutexptr) -> SbThreadAutoLock
        __init__(SbThreadAutoLock self, SbThreadMutex mutexptr) -> SbThreadAutoLock
        """
        _coin.SbThreadAutoLock_swiginit(self, _coin.new_SbThreadAutoLock(*args))
    __swig_destroy__ = _coin.delete_SbThreadAutoLock

# Register SbThreadAutoLock in _coin:
_coin.SbThreadAutoLock_swigregister(SbThreadAutoLock)
class SbCondVar(object):
    r"""Proxy of C++ SbCondVar class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SbCondVar self) -> SbCondVar"""
        _coin.SbCondVar_swiginit(self, _coin.new_SbCondVar())
    __swig_destroy__ = _coin.delete_SbCondVar

    def wait(self, mutex):
        r"""wait(SbCondVar self, SbMutex mutex) -> SbBool"""
        return _coin.SbCondVar_wait(self, mutex)

    def timedWait(self, mutex, period):
        r"""timedWait(SbCondVar self, SbMutex mutex, SbTime period) -> SbBool"""
        return _coin.SbCondVar_timedWait(self, mutex, period)

    def wakeOne(self):
        r"""wakeOne(SbCondVar self)"""
        return _coin.SbCondVar_wakeOne(self)

    def wakeAll(self):
        r"""wakeAll(SbCondVar self)"""
        return _coin.SbCondVar_wakeAll(self)

# Register SbCondVar in _coin:
_coin.SbCondVar_swigregister(SbCondVar)
class SbFifo(object):
    r"""Proxy of C++ SbFifo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SbFifo self) -> SbFifo"""
        _coin.SbFifo_swiginit(self, _coin.new_SbFifo())
    __swig_destroy__ = _coin.delete_SbFifo

    def assign(self, ptr, type):
        r"""assign(SbFifo self, void * ptr, uint32_t type)"""
        return _coin.SbFifo_assign(self, ptr, type)

    def retrieve(self, ptr, type):
        r"""retrieve(SbFifo self, void *& ptr, uint32_t & type)"""
        return _coin.SbFifo_retrieve(self, ptr, type)

    def tryRetrieve(self, ptr, type):
        r"""tryRetrieve(SbFifo self, void *& ptr, uint32_t & type) -> SbBool"""
        return _coin.SbFifo_tryRetrieve(self, ptr, type)

    def size(self):
        r"""size(SbFifo self) -> unsigned int"""
        return _coin.SbFifo_size(self)

    def lock(self):
        r"""lock(SbFifo self)"""
        return _coin.SbFifo_lock(self)

    def unlock(self):
        r"""unlock(SbFifo self)"""
        return _coin.SbFifo_unlock(self)

    def peek(self, item, type):
        r"""peek(SbFifo self, void *& item, uint32_t & type) -> SbBool"""
        return _coin.SbFifo_peek(self, item, type)

    def contains(self, item):
        r"""contains(SbFifo self, void * item) -> SbBool"""
        return _coin.SbFifo_contains(self, item)

    def reclaim(self, item):
        r"""reclaim(SbFifo self, void * item) -> SbBool"""
        return _coin.SbFifo_reclaim(self, item)

# Register SbFifo in _coin:
_coin.SbFifo_swigregister(SbFifo)
class SbRWMutex(object):
    r"""Proxy of C++ SbRWMutex class."""

    thisown = 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):
        r"""__init__(SbRWMutex self, SbRWMutex::Precedence policy) -> SbRWMutex"""
        _coin.SbRWMutex_swiginit(self, _coin.new_SbRWMutex(policy))
    __swig_destroy__ = _coin.delete_SbRWMutex

    def writeLock(self):
        r"""writeLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_writeLock(self)

    def tryWriteLock(self):
        r"""tryWriteLock(SbRWMutex self) -> SbBool"""
        return _coin.SbRWMutex_tryWriteLock(self)

    def writeUnlock(self):
        r"""writeUnlock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_writeUnlock(self)

    def readLock(self):
        r"""readLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_readLock(self)

    def tryReadLock(self):
        r"""tryReadLock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_tryReadLock(self)

    def readUnlock(self):
        r"""readUnlock(SbRWMutex self) -> int"""
        return _coin.SbRWMutex_readUnlock(self)

# Register SbRWMutex in _coin:
_coin.SbRWMutex_swigregister(SbRWMutex)
class SbStorage(object):
    r"""Proxy of C++ SbStorage class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(SbStorage self, unsigned int size) -> SbStorage
        __init__(SbStorage self, unsigned int size, cc_storage_f * constr, cc_storage_f * destr) -> SbStorage
        """
        _coin.SbStorage_swiginit(self, _coin.new_SbStorage(*args))
    __swig_destroy__ = _coin.delete_SbStorage

    def get(self):
        r"""get(SbStorage self) -> void *"""
        return _coin.SbStorage_get(self)

    def applyToAll(self, func, closure):
        r"""applyToAll(SbStorage self, SbStorageApplyFunc * func, void * closure)"""
        return _coin.SbStorage_applyToAll(self, func, closure)

# Register SbStorage in _coin:
_coin.SbStorage_swigregister(SbStorage)
class SbThread(object):
    r"""Proxy of C++ SbThread class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def create(func, closure):
        r"""create(void *(*)(void *) func, void * closure) -> SbThread"""
        return _coin.SbThread_create(func, closure)

    @staticmethod
    def destroy(thread):
        r"""destroy(SbThread thread)"""
        return _coin.SbThread_destroy(thread)

    @staticmethod
    def join(*args):
        r"""
        join(void ** retval=None) -> SbBool
        join(SbThread thread, void ** retval=None) -> SbBool
        """
        return _coin.SbThread_join(*args)

# Register SbThread in _coin:
_coin.SbThread_swigregister(SbThread)
class SoVRMLParent(SoGroup):
    r"""Proxy of C++ SoVRMLParent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLParent_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLParent self) -> SoType"""
        return _coin.SoVRMLParent_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLParent_initClass()
    children = property(_coin.SoVRMLParent_children_get, _coin.SoVRMLParent_children_set, doc=r"""children : SoMFNode""")

    def affectsState(self):
        r"""affectsState(SoVRMLParent self) -> SbBool"""
        return _coin.SoVRMLParent_affectsState(self)

    def addChild(self, child):
        r"""addChild(SoVRMLParent self, SoNode child)"""
        return _coin.SoVRMLParent_addChild(self, child)

    def insertChild(self, child, idx):
        r"""insertChild(SoVRMLParent self, SoNode child, int idx)"""
        return _coin.SoVRMLParent_insertChild(self, child, idx)

    def getChild(self, idx):
        r"""getChild(SoVRMLParent self, int idx) -> SoNode"""
        return _coin.SoVRMLParent_getChild(self, idx)

    def findChild(self, child):
        r"""findChild(SoVRMLParent self, SoNode child) -> int"""
        return _coin.SoVRMLParent_findChild(self, child)

    def getNumChildren(self):
        r"""getNumChildren(SoVRMLParent self) -> int"""
        return _coin.SoVRMLParent_getNumChildren(self)

    def removeChild(self, *args):
        r"""
        removeChild(SoVRMLParent self, int idx)
        removeChild(SoVRMLParent self, SoNode child)
        """
        return _coin.SoVRMLParent_removeChild(self, *args)

    def removeAllChildren(self):
        r"""removeAllChildren(SoVRMLParent self)"""
        return _coin.SoVRMLParent_removeAllChildren(self)

    def replaceChild(self, *args):
        r"""
        replaceChild(SoVRMLParent self, int idx, SoNode child)
        replaceChild(SoVRMLParent self, SoNode old, SoNode child)
        """
        return _coin.SoVRMLParent_replaceChild(self, *args)

    def getChildren(self):
        r"""getChildren(SoVRMLParent self) -> SoChildList"""
        return _coin.SoVRMLParent_getChildren(self)

    def doAction(self, action):
        r"""doAction(SoVRMLParent self, SoAction action)"""
        return _coin.SoVRMLParent_doAction(self, action)

    def search(self, action):
        r"""search(SoVRMLParent self, SoSearchAction action)"""
        return _coin.SoVRMLParent_search(self, action)

    def write(self, action):
        r"""write(SoVRMLParent self, SoWriteAction action)"""
        return _coin.SoVRMLParent_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLParent self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLParent_getPrimitiveCount(self, action)

    @staticmethod
    def updateChildList(*args):
        r"""
        updateChildList(SoNode const *const * nodes, int const numnodes, SoChildList cl)
        updateChildList(SoNode nodewithsfnode, SoChildList cl)
        """
        return _coin.SoVRMLParent_updateChildList(*args)

# Register SoVRMLParent in _coin:
_coin.SoVRMLParent_swigregister(SoVRMLParent)
class SoVRMLAnchor(SoVRMLParent):
    r"""Proxy of C++ SoVRMLAnchor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLAnchor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLAnchor self) -> SoType"""
        return _coin.SoVRMLAnchor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLAnchor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLAnchor self) -> SoVRMLAnchor"""
        _coin.SoVRMLAnchor_swiginit(self, _coin.new_SoVRMLAnchor())
    url = property(_coin.SoVRMLAnchor_url_get, _coin.SoVRMLAnchor_url_set, doc=r"""url : SoMFString""")
    description = property(_coin.SoVRMLAnchor_description_get, _coin.SoVRMLAnchor_description_set, doc=r"""description : SoSFString""")
    parameter = property(_coin.SoVRMLAnchor_parameter_get, _coin.SoVRMLAnchor_parameter_set, doc=r"""parameter : SoMFString""")
    bboxCenter = property(_coin.SoVRMLAnchor_bboxCenter_get, _coin.SoVRMLAnchor_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoVRMLAnchor_bboxSize_get, _coin.SoVRMLAnchor_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")

    @staticmethod
    def setFetchURLCallBack(arg1, closure):
        r"""setFetchURLCallBack(SoVRMLAnchorCB * arg1, void * closure)"""
        return _coin.SoVRMLAnchor_setFetchURLCallBack(arg1, closure)

    def handleEvent(self, action):
        r"""handleEvent(SoVRMLAnchor self, SoHandleEventAction action)"""
        return _coin.SoVRMLAnchor_handleEvent(self, action)

# Register SoVRMLAnchor in _coin:
_coin.SoVRMLAnchor_swigregister(SoVRMLAnchor)
class SoVRMLAppearance(SoNode):
    r"""Proxy of C++ SoVRMLAppearance class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLAppearance_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLAppearance self) -> SoType"""
        return _coin.SoVRMLAppearance_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLAppearance_initClass()

    def __init__(self):
        r"""__init__(SoVRMLAppearance self) -> SoVRMLAppearance"""
        _coin.SoVRMLAppearance_swiginit(self, _coin.new_SoVRMLAppearance())
    material = property(_coin.SoVRMLAppearance_material_get, _coin.SoVRMLAppearance_material_set, doc=r"""material : SoSFNode""")
    texture = property(_coin.SoVRMLAppearance_texture_get, _coin.SoVRMLAppearance_texture_set, doc=r"""texture : SoSFNode""")
    textureTransform = property(_coin.SoVRMLAppearance_textureTransform_get, _coin.SoVRMLAppearance_textureTransform_set, doc=r"""textureTransform : SoSFNode""")

    def doAction(self, action):
        r"""doAction(SoVRMLAppearance self, SoAction action)"""
        return _coin.SoVRMLAppearance_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLAppearance self, SoCallbackAction action)"""
        return _coin.SoVRMLAppearance_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLAppearance self, SoGLRenderAction action)"""
        return _coin.SoVRMLAppearance_GLRender(self, action)

    def search(self, action):
        r"""search(SoVRMLAppearance self, SoSearchAction action)"""
        return _coin.SoVRMLAppearance_search(self, action)

    def getChildren(self):
        r"""getChildren(SoVRMLAppearance self) -> SoChildList"""
        return _coin.SoVRMLAppearance_getChildren(self)

    def notify(self, list):
        r"""notify(SoVRMLAppearance self, SoNotList list)"""
        return _coin.SoVRMLAppearance_notify(self, list)

    def copyContents(self, srcFrom, copyConn):
        r"""copyContents(SoVRMLAppearance self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLAppearance_copyContents(self, srcFrom, copyConn)

# Register SoVRMLAppearance in _coin:
_coin.SoVRMLAppearance_swigregister(SoVRMLAppearance)
class SoVRMLAudioClip(SoNode):
    r"""Proxy of C++ SoVRMLAudioClip class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLAudioClip_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLAudioClip self) -> SoType"""
        return _coin.SoVRMLAudioClip_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLAudioClip_initClass()

    def __init__(self):
        r"""__init__(SoVRMLAudioClip self) -> SoVRMLAudioClip"""
        _coin.SoVRMLAudioClip_swiginit(self, _coin.new_SoVRMLAudioClip())
    description = property(_coin.SoVRMLAudioClip_description_get, _coin.SoVRMLAudioClip_description_set, doc=r"""description : SoSFString""")
    loop = property(_coin.SoVRMLAudioClip_loop_get, _coin.SoVRMLAudioClip_loop_set, doc=r"""loop : SoSFBool""")
    pitch = property(_coin.SoVRMLAudioClip_pitch_get, _coin.SoVRMLAudioClip_pitch_set, doc=r"""pitch : SoSFFloat""")
    startTime = property(_coin.SoVRMLAudioClip_startTime_get, _coin.SoVRMLAudioClip_startTime_set, doc=r"""startTime : SoSFTime""")
    stopTime = property(_coin.SoVRMLAudioClip_stopTime_get, _coin.SoVRMLAudioClip_stopTime_set, doc=r"""stopTime : SoSFTime""")
    url = property(_coin.SoVRMLAudioClip_url_get, _coin.SoVRMLAudioClip_url_set, doc=r"""url : SoMFString""")

    @staticmethod
    def setSubdirectories(subdirectories):
        r"""setSubdirectories(SbList< SbString > const & subdirectories)"""
        return _coin.SoVRMLAudioClip_setSubdirectories(subdirectories)

    @staticmethod
    def getSubdirectories():
        r"""getSubdirectories() -> SbStringList"""
        return _coin.SoVRMLAudioClip_getSubdirectories()

    @staticmethod
    def setDefaultPauseBetweenTracks(pause):
        r"""setDefaultPauseBetweenTracks(SbTime pause)"""
        return _coin.SoVRMLAudioClip_setDefaultPauseBetweenTracks(pause)

    @staticmethod
    def getDefaultPauseBetweenTracks():
        r"""getDefaultPauseBetweenTracks() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultPauseBetweenTracks()

    @staticmethod
    def setDefaultIntroPause(pause):
        r"""setDefaultIntroPause(SbTime pause)"""
        return _coin.SoVRMLAudioClip_setDefaultIntroPause(pause)

    @staticmethod
    def getDefaultIntroPause():
        r"""getDefaultIntroPause() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultIntroPause()

    @staticmethod
    def setDefaultSampleRate(samplerate):
        r"""setDefaultSampleRate(int samplerate)"""
        return _coin.SoVRMLAudioClip_setDefaultSampleRate(samplerate)

    @staticmethod
    def getDefaultSampleRate():
        r"""getDefaultSampleRate() -> int"""
        return _coin.SoVRMLAudioClip_getDefaultSampleRate()

    @staticmethod
    def setDefaultTimerInterval(interval):
        r"""setDefaultTimerInterval(SbTime interval)"""
        return _coin.SoVRMLAudioClip_setDefaultTimerInterval(interval)

    @staticmethod
    def getDefaultTimerInterval():
        r"""getDefaultTimerInterval() -> SbTime"""
        return _coin.SoVRMLAudioClip_getDefaultTimerInterval()

    def getSampleRate(self):
        r"""getSampleRate(SoVRMLAudioClip self) -> int"""
        return _coin.SoVRMLAudioClip_getSampleRate(self)

    def open(self, url):
        r"""open(SoVRMLAudioClip self, SbStringList url) -> void *"""
        return _coin.SoVRMLAudioClip_open(self, url)

    def read(self, datasource, buffer, numframes, channels):
        r"""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):
        r"""seek(SoVRMLAudioClip self, void * datasource, long offset, int whence) -> int"""
        return _coin.SoVRMLAudioClip_seek(self, datasource, offset, whence)

    def tell(self, datasource):
        r"""tell(SoVRMLAudioClip self, void * datasource) -> long"""
        return _coin.SoVRMLAudioClip_tell(self, datasource)

    def close(self, datasource):
        r"""close(SoVRMLAudioClip self, void * datasource) -> int"""
        return _coin.SoVRMLAudioClip_close(self, datasource)

    def setCallbacks(self, opencb, readcb, seekcb, tellcb, closecb, userdataptr):
        r"""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)

# Register SoVRMLAudioClip in _coin:
_coin.SoVRMLAudioClip_swigregister(SoVRMLAudioClip)
class SoVRMLBackground(SoNode):
    r"""Proxy of C++ SoVRMLBackground class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLBackground_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLBackground self) -> SoType"""
        return _coin.SoVRMLBackground_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLBackground_initClass()

    def __init__(self):
        r"""__init__(SoVRMLBackground self) -> SoVRMLBackground"""
        _coin.SoVRMLBackground_swiginit(self, _coin.new_SoVRMLBackground())
    groundColor = property(_coin.SoVRMLBackground_groundColor_get, _coin.SoVRMLBackground_groundColor_set, doc=r"""groundColor : SoMFColor""")
    groundAngle = property(_coin.SoVRMLBackground_groundAngle_get, _coin.SoVRMLBackground_groundAngle_set, doc=r"""groundAngle : SoMFFloat""")
    skyColor = property(_coin.SoVRMLBackground_skyColor_get, _coin.SoVRMLBackground_skyColor_set, doc=r"""skyColor : SoMFColor""")
    skyAngle = property(_coin.SoVRMLBackground_skyAngle_get, _coin.SoVRMLBackground_skyAngle_set, doc=r"""skyAngle : SoMFFloat""")
    backUrl = property(_coin.SoVRMLBackground_backUrl_get, _coin.SoVRMLBackground_backUrl_set, doc=r"""backUrl : SoMFString""")
    bottomUrl = property(_coin.SoVRMLBackground_bottomUrl_get, _coin.SoVRMLBackground_bottomUrl_set, doc=r"""bottomUrl : SoMFString""")
    frontUrl = property(_coin.SoVRMLBackground_frontUrl_get, _coin.SoVRMLBackground_frontUrl_set, doc=r"""frontUrl : SoMFString""")
    leftUrl = property(_coin.SoVRMLBackground_leftUrl_get, _coin.SoVRMLBackground_leftUrl_set, doc=r"""leftUrl : SoMFString""")
    rightUrl = property(_coin.SoVRMLBackground_rightUrl_get, _coin.SoVRMLBackground_rightUrl_set, doc=r"""rightUrl : SoMFString""")
    topUrl = property(_coin.SoVRMLBackground_topUrl_get, _coin.SoVRMLBackground_topUrl_set, doc=r"""topUrl : SoMFString""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLBackground self, SoGLRenderAction action)"""
        return _coin.SoVRMLBackground_GLRender(self, action)

# Register SoVRMLBackground in _coin:
_coin.SoVRMLBackground_swigregister(SoVRMLBackground)
class SoVRMLBillboard(SoVRMLParent):
    r"""Proxy of C++ SoVRMLBillboard class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLBillboard_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLBillboard self) -> SoType"""
        return _coin.SoVRMLBillboard_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLBillboard_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLBillboard self) -> SoVRMLBillboard
        __init__(SoVRMLBillboard self, int numchildren) -> SoVRMLBillboard
        """
        _coin.SoVRMLBillboard_swiginit(self, _coin.new_SoVRMLBillboard(*args))
    axisOfRotation = property(_coin.SoVRMLBillboard_axisOfRotation_get, _coin.SoVRMLBillboard_axisOfRotation_set, doc=r"""axisOfRotation : SoSFVec3f""")
    bboxCenter = property(_coin.SoVRMLBillboard_bboxCenter_get, _coin.SoVRMLBillboard_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoVRMLBillboard_bboxSize_get, _coin.SoVRMLBillboard_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")

    def doAction(self, action):
        r"""doAction(SoVRMLBillboard self, SoAction action)"""
        return _coin.SoVRMLBillboard_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLBillboard self, SoCallbackAction action)"""
        return _coin.SoVRMLBillboard_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLBillboard self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLBillboard_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoVRMLBillboard self, SoGetMatrixAction action)"""
        return _coin.SoVRMLBillboard_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoVRMLBillboard self, SoPickAction action)"""
        return _coin.SoVRMLBillboard_pick(self, action)

    def search(self, action):
        r"""search(SoVRMLBillboard self, SoSearchAction action)"""
        return _coin.SoVRMLBillboard_search(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action):
        r"""GLRenderInPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action):
        r"""GLRenderOffPath(SoVRMLBillboard self, SoGLRenderAction action)"""
        return _coin.SoVRMLBillboard_GLRenderOffPath(self, action)

    def notify(self, list):
        r"""notify(SoVRMLBillboard self, SoNotList list)"""
        return _coin.SoVRMLBillboard_notify(self, list)

# Register SoVRMLBillboard in _coin:
_coin.SoVRMLBillboard_swigregister(SoVRMLBillboard)
class SoVRMLGeometry(SoShape):
    r"""Proxy of C++ SoVRMLGeometry class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLGeometry_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLGeometry self) -> SoType"""
        return _coin.SoVRMLGeometry_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLGeometry_initClass()

    def search(self, action):
        r"""search(SoVRMLGeometry self, SoSearchAction action)"""
        return _coin.SoVRMLGeometry_search(self, action)

    def copyContents(self, srcFrom, copyConn):
        r"""copyContents(SoVRMLGeometry self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLGeometry_copyContents(self, srcFrom, copyConn)

# Register SoVRMLGeometry in _coin:
_coin.SoVRMLGeometry_swigregister(SoVRMLGeometry)
class SoVRMLBox(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLBox class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLBox_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLBox self) -> SoType"""
        return _coin.SoVRMLBox_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLBox_initClass()

    def __init__(self):
        r"""__init__(SoVRMLBox self) -> SoVRMLBox"""
        _coin.SoVRMLBox_swiginit(self, _coin.new_SoVRMLBox())
    size = property(_coin.SoVRMLBox_size_get, _coin.SoVRMLBox_size_set, doc=r"""size : SoSFVec3f""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLBox self, SoGLRenderAction action)"""
        return _coin.SoVRMLBox_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLBox self, SoRayPickAction action)"""
        return _coin.SoVRMLBox_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLBox self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLBox_getPrimitiveCount(self, action)

# Register SoVRMLBox in _coin:
_coin.SoVRMLBox_swigregister(SoVRMLBox)
class SoVRMLGroup(SoVRMLParent):
    r"""Proxy of C++ SoVRMLGroup class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLGroup_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLGroup self) -> SoType"""
        return _coin.SoVRMLGroup_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLGroup_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLGroup self) -> SoVRMLGroup
        __init__(SoVRMLGroup self, int numChildren) -> SoVRMLGroup
        """
        _coin.SoVRMLGroup_swiginit(self, _coin.new_SoVRMLGroup(*args))
    OFF = _coin.SoVRMLGroup_OFF
    
    ON = _coin.SoVRMLGroup_ON
    
    AUTO = _coin.SoVRMLGroup_AUTO
    
    renderCaching = property(_coin.SoVRMLGroup_renderCaching_get, _coin.SoVRMLGroup_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoVRMLGroup_boundingBoxCaching_get, _coin.SoVRMLGroup_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")
    renderCulling = property(_coin.SoVRMLGroup_renderCulling_get, _coin.SoVRMLGroup_renderCulling_set, doc=r"""renderCulling : SoSFEnum""")
    pickCulling = property(_coin.SoVRMLGroup_pickCulling_get, _coin.SoVRMLGroup_pickCulling_set, doc=r"""pickCulling : SoSFEnum""")
    bboxCenter = property(_coin.SoVRMLGroup_bboxCenter_get, _coin.SoVRMLGroup_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoVRMLGroup_bboxSize_get, _coin.SoVRMLGroup_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")

    @staticmethod
    def setNumRenderCaches(num):
        r"""setNumRenderCaches(int num)"""
        return _coin.SoVRMLGroup_setNumRenderCaches(num)

    @staticmethod
    def getNumRenderCaches():
        r"""getNumRenderCaches() -> int"""
        return _coin.SoVRMLGroup_getNumRenderCaches()

    def doAction(self, action):
        r"""doAction(SoVRMLGroup self, SoAction action)"""
        return _coin.SoVRMLGroup_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLGroup self, SoCallbackAction action)"""
        return _coin.SoVRMLGroup_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLGroup self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLGroup_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoVRMLGroup self, SoGetMatrixAction action)"""
        return _coin.SoVRMLGroup_getMatrix(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLGroup self, SoRayPickAction action)"""
        return _coin.SoVRMLGroup_rayPick(self, action)

    def search(self, action):
        r"""search(SoVRMLGroup self, SoSearchAction action)"""
        return _coin.SoVRMLGroup_search(self, action)

    def write(self, action):
        r"""write(SoVRMLGroup self, SoWriteAction action)"""
        return _coin.SoVRMLGroup_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLGroup self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLGroup_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoVRMLGroup self, SoAudioRenderAction action)"""
        return _coin.SoVRMLGroup_audioRender(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action):
        r"""GLRenderInPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action):
        r"""GLRenderOffPath(SoVRMLGroup self, SoGLRenderAction action)"""
        return _coin.SoVRMLGroup_GLRenderOffPath(self, action)

    def notify(self, list):
        r"""notify(SoVRMLGroup self, SoNotList list)"""
        return _coin.SoVRMLGroup_notify(self, list)

# Register SoVRMLGroup in _coin:
_coin.SoVRMLGroup_swigregister(SoVRMLGroup)
class SoVRMLCollision(SoVRMLGroup):
    r"""Proxy of C++ SoVRMLCollision class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCollision_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLCollision self) -> SoType"""
        return _coin.SoVRMLCollision_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLCollision_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLCollision self) -> SoVRMLCollision
        __init__(SoVRMLCollision self, int numchildren) -> SoVRMLCollision
        """
        _coin.SoVRMLCollision_swiginit(self, _coin.new_SoVRMLCollision(*args))
    collide = property(_coin.SoVRMLCollision_collide_get, _coin.SoVRMLCollision_collide_set, doc=r"""collide : SoSFBool""")
    proxy = property(_coin.SoVRMLCollision_proxy_get, _coin.SoVRMLCollision_proxy_set, doc=r"""proxy : SoSFNode""")
    collideTime = property(_coin.SoVRMLCollision_collideTime_get, _coin.SoVRMLCollision_collideTime_set, doc=r"""collideTime : SoSFTime""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLCollision self, SoGLRenderAction action)"""
        return _coin.SoVRMLCollision_GLRender(self, action)

    def notify(self, list):
        r"""notify(SoVRMLCollision self, SoNotList list)"""
        return _coin.SoVRMLCollision_notify(self, list)

# Register SoVRMLCollision in _coin:
_coin.SoVRMLCollision_swigregister(SoVRMLCollision)
class SoVRMLColor(SoNode):
    r"""Proxy of C++ SoVRMLColor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLColor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLColor self) -> SoType"""
        return _coin.SoVRMLColor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLColor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLColor self) -> SoVRMLColor"""
        _coin.SoVRMLColor_swiginit(self, _coin.new_SoVRMLColor())
    color = property(_coin.SoVRMLColor_color_get, _coin.SoVRMLColor_color_set, doc=r"""color : SoMFColor""")

    def doAction(self, action):
        r"""doAction(SoVRMLColor self, SoAction action)"""
        return _coin.SoVRMLColor_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLColor self, SoGLRenderAction action)"""
        return _coin.SoVRMLColor_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoVRMLColor self, SoCallbackAction action)"""
        return _coin.SoVRMLColor_callback(self, action)

# Register SoVRMLColor in _coin:
_coin.SoVRMLColor_swigregister(SoVRMLColor)
class SoVRMLInterpolator(SoNodeEngine):
    r"""Proxy of C++ SoVRMLInterpolator class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLInterpolator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLInterpolator self) -> SoType"""
        return _coin.SoVRMLInterpolator_getTypeId(self)

    def getOutputData(self):
        r"""getOutputData(SoVRMLInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLInterpolator_getOutputData(self)
    key = property(_coin.SoVRMLInterpolator_key_get, _coin.SoVRMLInterpolator_key_set, doc=r"""key : SoMFFloat""")
    set_fraction = property(_coin.SoVRMLInterpolator_set_fraction_get, _coin.SoVRMLInterpolator_set_fraction_set, doc=r"""set_fraction : SoSFFloat""")

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLInterpolator_initClass()

# Register SoVRMLInterpolator in _coin:
_coin.SoVRMLInterpolator_swigregister(SoVRMLInterpolator)
class SoVRMLColorInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLColorInterpolator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLColorInterpolator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLColorInterpolator self) -> SoType"""
        return _coin.SoVRMLColorInterpolator_getTypeId(self)

    def getOutputData(self):
        r"""getOutputData(SoVRMLColorInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLColorInterpolator_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVRMLColorInterpolator_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLColorInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLColorInterpolator self) -> SoVRMLColorInterpolator"""
        _coin.SoVRMLColorInterpolator_swiginit(self, _coin.new_SoVRMLColorInterpolator())
    keyValue = property(_coin.SoVRMLColorInterpolator_keyValue_get, _coin.SoVRMLColorInterpolator_keyValue_set, doc=r"""keyValue : SoMFColor""")
    value_changed = property(_coin.SoVRMLColorInterpolator_value_changed_get, _coin.SoVRMLColorInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLColorInterpolator in _coin:
_coin.SoVRMLColorInterpolator_swigregister(SoVRMLColorInterpolator)
class SoVRMLCone(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLCone class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCone_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLCone self) -> SoType"""
        return _coin.SoVRMLCone_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLCone_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCone self) -> SoVRMLCone"""
        _coin.SoVRMLCone_swiginit(self, _coin.new_SoVRMLCone())
    bottomRadius = property(_coin.SoVRMLCone_bottomRadius_get, _coin.SoVRMLCone_bottomRadius_set, doc=r"""bottomRadius : SoSFFloat""")
    height = property(_coin.SoVRMLCone_height_get, _coin.SoVRMLCone_height_set, doc=r"""height : SoSFFloat""")
    side = property(_coin.SoVRMLCone_side_get, _coin.SoVRMLCone_side_set, doc=r"""side : SoSFBool""")
    bottom = property(_coin.SoVRMLCone_bottom_get, _coin.SoVRMLCone_bottom_set, doc=r"""bottom : SoSFBool""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLCone self, SoGLRenderAction action)"""
        return _coin.SoVRMLCone_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLCone self, SoRayPickAction action)"""
        return _coin.SoVRMLCone_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLCone self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLCone_getPrimitiveCount(self, action)

# Register SoVRMLCone in _coin:
_coin.SoVRMLCone_swigregister(SoVRMLCone)
class SoVRMLCoordinate(SoNode):
    r"""Proxy of C++ SoVRMLCoordinate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCoordinate_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLCoordinate self) -> SoType"""
        return _coin.SoVRMLCoordinate_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLCoordinate_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCoordinate self) -> SoVRMLCoordinate"""
        _coin.SoVRMLCoordinate_swiginit(self, _coin.new_SoVRMLCoordinate())
    point = property(_coin.SoVRMLCoordinate_point_get, _coin.SoVRMLCoordinate_point_set, doc=r"""point : SoMFVec3f""")

    def doAction(self, action):
        r"""doAction(SoVRMLCoordinate self, SoAction action)"""
        return _coin.SoVRMLCoordinate_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLCoordinate self, SoGLRenderAction action)"""
        return _coin.SoVRMLCoordinate_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLCoordinate self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLCoordinate_getBoundingBox(self, action)

    def callback(self, action):
        r"""callback(SoVRMLCoordinate self, SoCallbackAction action)"""
        return _coin.SoVRMLCoordinate_callback(self, action)

    def pick(self, action):
        r"""pick(SoVRMLCoordinate self, SoPickAction action)"""
        return _coin.SoVRMLCoordinate_pick(self, action)

# Register SoVRMLCoordinate in _coin:
_coin.SoVRMLCoordinate_swigregister(SoVRMLCoordinate)
class SoVRMLCoordinateInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLCoordinateInterpolator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCoordinateInterpolator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLCoordinateInterpolator self) -> SoType"""
        return _coin.SoVRMLCoordinateInterpolator_getTypeId(self)

    def getOutputData(self):
        r"""getOutputData(SoVRMLCoordinateInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLCoordinateInterpolator_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVRMLCoordinateInterpolator_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLCoordinateInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCoordinateInterpolator self) -> SoVRMLCoordinateInterpolator"""
        _coin.SoVRMLCoordinateInterpolator_swiginit(self, _coin.new_SoVRMLCoordinateInterpolator())
    keyValue = property(_coin.SoVRMLCoordinateInterpolator_keyValue_get, _coin.SoVRMLCoordinateInterpolator_keyValue_set, doc=r"""keyValue : SoMFVec3f""")
    value_changed = property(_coin.SoVRMLCoordinateInterpolator_value_changed_get, _coin.SoVRMLCoordinateInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLCoordinateInterpolator in _coin:
_coin.SoVRMLCoordinateInterpolator_swigregister(SoVRMLCoordinateInterpolator)
class SoVRMLCylinder(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLCylinder class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCylinder_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLCylinder self) -> SoType"""
        return _coin.SoVRMLCylinder_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLCylinder_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCylinder self) -> SoVRMLCylinder"""
        _coin.SoVRMLCylinder_swiginit(self, _coin.new_SoVRMLCylinder())
    radius = property(_coin.SoVRMLCylinder_radius_get, _coin.SoVRMLCylinder_radius_set, doc=r"""radius : SoSFFloat""")
    height = property(_coin.SoVRMLCylinder_height_get, _coin.SoVRMLCylinder_height_set, doc=r"""height : SoSFFloat""")
    side = property(_coin.SoVRMLCylinder_side_get, _coin.SoVRMLCylinder_side_set, doc=r"""side : SoSFBool""")
    top = property(_coin.SoVRMLCylinder_top_get, _coin.SoVRMLCylinder_top_set, doc=r"""top : SoSFBool""")
    bottom = property(_coin.SoVRMLCylinder_bottom_get, _coin.SoVRMLCylinder_bottom_set, doc=r"""bottom : SoSFBool""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLCylinder self, SoGLRenderAction action)"""
        return _coin.SoVRMLCylinder_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLCylinder self, SoRayPickAction action)"""
        return _coin.SoVRMLCylinder_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLCylinder self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLCylinder_getPrimitiveCount(self, action)

# Register SoVRMLCylinder in _coin:
_coin.SoVRMLCylinder_swigregister(SoVRMLCylinder)
class SoVRMLSensor(SoNode):
    r"""Proxy of C++ SoVRMLSensor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLSensor self) -> SoType"""
        return _coin.SoVRMLSensor_getTypeId(self)
    isActive = property(_coin.SoVRMLSensor_isActive_get, _coin.SoVRMLSensor_isActive_set, doc=r"""isActive : SoSFBool""")
    enabled = property(_coin.SoVRMLSensor_enabled_get, _coin.SoVRMLSensor_enabled_set, doc=r"""enabled : SoSFBool""")

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLSensor_initClass()

# Register SoVRMLSensor in _coin:
_coin.SoVRMLSensor_swigregister(SoVRMLSensor)
class SoVRMLDragSensor(SoVRMLSensor):
    r"""Proxy of C++ SoVRMLDragSensor class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLDragSensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLDragSensor self) -> SoType"""
        return _coin.SoVRMLDragSensor_getTypeId(self)
    trackPoint_changed = property(_coin.SoVRMLDragSensor_trackPoint_changed_get, _coin.SoVRMLDragSensor_trackPoint_changed_set, doc=r"""trackPoint_changed : SoSFVec3f""")
    autoOffset = property(_coin.SoVRMLDragSensor_autoOffset_get, _coin.SoVRMLDragSensor_autoOffset_set, doc=r"""autoOffset : SoSFBool""")

    def handleEvent(self, action):
        r"""handleEvent(SoVRMLDragSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLDragSensor_handleEvent(self, action)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLDragSensor_initClass()

# Register SoVRMLDragSensor in _coin:
_coin.SoVRMLDragSensor_swigregister(SoVRMLDragSensor)
class SoVRMLCylinderSensor(SoVRMLDragSensor):
    r"""Proxy of C++ SoVRMLCylinderSensor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLCylinderSensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLCylinderSensor self) -> SoType"""
        return _coin.SoVRMLCylinderSensor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLCylinderSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLCylinderSensor self) -> SoVRMLCylinderSensor"""
        _coin.SoVRMLCylinderSensor_swiginit(self, _coin.new_SoVRMLCylinderSensor())
    diskAngle = property(_coin.SoVRMLCylinderSensor_diskAngle_get, _coin.SoVRMLCylinderSensor_diskAngle_set, doc=r"""diskAngle : SoSFFloat""")
    maxAngle = property(_coin.SoVRMLCylinderSensor_maxAngle_get, _coin.SoVRMLCylinderSensor_maxAngle_set, doc=r"""maxAngle : SoSFFloat""")
    minAngle = property(_coin.SoVRMLCylinderSensor_minAngle_get, _coin.SoVRMLCylinderSensor_minAngle_set, doc=r"""minAngle : SoSFFloat""")
    offset = property(_coin.SoVRMLCylinderSensor_offset_get, _coin.SoVRMLCylinderSensor_offset_set, doc=r"""offset : SoSFFloat""")
    rotation_changed = property(_coin.SoVRMLCylinderSensor_rotation_changed_get, _coin.SoVRMLCylinderSensor_rotation_changed_set, doc=r"""rotation_changed : SoSFRotation""")

# Register SoVRMLCylinderSensor in _coin:
_coin.SoVRMLCylinderSensor_swigregister(SoVRMLCylinderSensor)
class SoVRMLLight(SoNode):
    r"""Proxy of C++ SoVRMLLight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLLight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLLight self) -> SoType"""
        return _coin.SoVRMLLight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLLight_initClass()
    on = property(_coin.SoVRMLLight_on_get, _coin.SoVRMLLight_on_set, doc=r"""on : SoSFBool""")
    intensity = property(_coin.SoVRMLLight_intensity_get, _coin.SoVRMLLight_intensity_set, doc=r"""intensity : SoSFFloat""")
    color = property(_coin.SoVRMLLight_color_get, _coin.SoVRMLLight_color_set, doc=r"""color : SoSFColor""")
    ambientIntensity = property(_coin.SoVRMLLight_ambientIntensity_get, _coin.SoVRMLLight_ambientIntensity_set, doc=r"""ambientIntensity : SoSFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLLight_GLRender(self, action)

# Register SoVRMLLight in _coin:
_coin.SoVRMLLight_swigregister(SoVRMLLight)
class SoVRMLDirectionalLight(SoVRMLLight):
    r"""Proxy of C++ SoVRMLDirectionalLight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLDirectionalLight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLDirectionalLight self) -> SoType"""
        return _coin.SoVRMLDirectionalLight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLDirectionalLight_initClass()

    def __init__(self):
        r"""__init__(SoVRMLDirectionalLight self) -> SoVRMLDirectionalLight"""
        _coin.SoVRMLDirectionalLight_swiginit(self, _coin.new_SoVRMLDirectionalLight())
    direction = property(_coin.SoVRMLDirectionalLight_direction_get, _coin.SoVRMLDirectionalLight_direction_set, doc=r"""direction : SoSFVec3f""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLDirectionalLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLDirectionalLight_GLRender(self, action)

# Register SoVRMLDirectionalLight in _coin:
_coin.SoVRMLDirectionalLight_swigregister(SoVRMLDirectionalLight)
class SoVRMLElevationGrid(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLElevationGrid class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLElevationGrid_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLElevationGrid self) -> SoType"""
        return _coin.SoVRMLElevationGrid_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLElevationGrid_initClass()

    def __init__(self):
        r"""__init__(SoVRMLElevationGrid self) -> SoVRMLElevationGrid"""
        _coin.SoVRMLElevationGrid_swiginit(self, _coin.new_SoVRMLElevationGrid())
    ccw = property(_coin.SoVRMLElevationGrid_ccw_get, _coin.SoVRMLElevationGrid_ccw_set, doc=r"""ccw : SoSFBool""")
    solid = property(_coin.SoVRMLElevationGrid_solid_get, _coin.SoVRMLElevationGrid_solid_set, doc=r"""solid : SoSFBool""")
    creaseAngle = property(_coin.SoVRMLElevationGrid_creaseAngle_get, _coin.SoVRMLElevationGrid_creaseAngle_set, doc=r"""creaseAngle : SoSFFloat""")
    zDimension = property(_coin.SoVRMLElevationGrid_zDimension_get, _coin.SoVRMLElevationGrid_zDimension_set, doc=r"""zDimension : SoSFInt32""")
    xDimension = property(_coin.SoVRMLElevationGrid_xDimension_get, _coin.SoVRMLElevationGrid_xDimension_set, doc=r"""xDimension : SoSFInt32""")
    zSpacing = property(_coin.SoVRMLElevationGrid_zSpacing_get, _coin.SoVRMLElevationGrid_zSpacing_set, doc=r"""zSpacing : SoSFFloat""")
    xSpacing = property(_coin.SoVRMLElevationGrid_xSpacing_get, _coin.SoVRMLElevationGrid_xSpacing_set, doc=r"""xSpacing : SoSFFloat""")
    height = property(_coin.SoVRMLElevationGrid_height_get, _coin.SoVRMLElevationGrid_height_set, doc=r"""height : SoMFFloat""")
    texCoord = property(_coin.SoVRMLElevationGrid_texCoord_get, _coin.SoVRMLElevationGrid_texCoord_set, doc=r"""texCoord : SoSFNode""")
    normal = property(_coin.SoVRMLElevationGrid_normal_get, _coin.SoVRMLElevationGrid_normal_set, doc=r"""normal : SoSFNode""")
    color = property(_coin.SoVRMLElevationGrid_color_get, _coin.SoVRMLElevationGrid_color_set, doc=r"""color : SoSFNode""")
    colorPerVertex = property(_coin.SoVRMLElevationGrid_colorPerVertex_get, _coin.SoVRMLElevationGrid_colorPerVertex_set, doc=r"""colorPerVertex : SoSFBool""")
    normalPerVertex = property(_coin.SoVRMLElevationGrid_normalPerVertex_get, _coin.SoVRMLElevationGrid_normalPerVertex_set, doc=r"""normalPerVertex : SoSFBool""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLElevationGrid self, SoGLRenderAction action)"""
        return _coin.SoVRMLElevationGrid_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLElevationGrid self, SoRayPickAction action)"""
        return _coin.SoVRMLElevationGrid_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLElevationGrid self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLElevationGrid_getPrimitiveCount(self, action)

# Register SoVRMLElevationGrid in _coin:
_coin.SoVRMLElevationGrid_swigregister(SoVRMLElevationGrid)
class SoVRMLExtrusion(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLExtrusion class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLExtrusion_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLExtrusion self) -> SoType"""
        return _coin.SoVRMLExtrusion_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLExtrusion_initClass()

    def __init__(self):
        r"""__init__(SoVRMLExtrusion self) -> SoVRMLExtrusion"""
        _coin.SoVRMLExtrusion_swiginit(self, _coin.new_SoVRMLExtrusion())
    beginCap = property(_coin.SoVRMLExtrusion_beginCap_get, _coin.SoVRMLExtrusion_beginCap_set, doc=r"""beginCap : SoSFBool""")
    ccw = property(_coin.SoVRMLExtrusion_ccw_get, _coin.SoVRMLExtrusion_ccw_set, doc=r"""ccw : SoSFBool""")
    convex = property(_coin.SoVRMLExtrusion_convex_get, _coin.SoVRMLExtrusion_convex_set, doc=r"""convex : SoSFBool""")
    creaseAngle = property(_coin.SoVRMLExtrusion_creaseAngle_get, _coin.SoVRMLExtrusion_creaseAngle_set, doc=r"""creaseAngle : SoSFFloat""")
    crossSection = property(_coin.SoVRMLExtrusion_crossSection_get, _coin.SoVRMLExtrusion_crossSection_set, doc=r"""crossSection : SoMFVec2f""")
    endCap = property(_coin.SoVRMLExtrusion_endCap_get, _coin.SoVRMLExtrusion_endCap_set, doc=r"""endCap : SoSFBool""")
    orientation = property(_coin.SoVRMLExtrusion_orientation_get, _coin.SoVRMLExtrusion_orientation_set, doc=r"""orientation : SoMFRotation""")
    scale = property(_coin.SoVRMLExtrusion_scale_get, _coin.SoVRMLExtrusion_scale_set, doc=r"""scale : SoMFVec2f""")
    solid = property(_coin.SoVRMLExtrusion_solid_get, _coin.SoVRMLExtrusion_solid_set, doc=r"""solid : SoSFBool""")
    spine = property(_coin.SoVRMLExtrusion_spine_get, _coin.SoVRMLExtrusion_spine_set, doc=r"""spine : SoMFVec3f""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLExtrusion self, SoGLRenderAction action)"""
        return _coin.SoVRMLExtrusion_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLExtrusion self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLExtrusion_getPrimitiveCount(self, action)

    def computeBBox(self, action, bbox, center):
        r"""computeBBox(SoVRMLExtrusion self, SoAction action, SbBox3f bbox, SbVec3f center)"""
        return _coin.SoVRMLExtrusion_computeBBox(self, action, bbox, center)

# Register SoVRMLExtrusion in _coin:
_coin.SoVRMLExtrusion_swigregister(SoVRMLExtrusion)
class SoVRMLFog(SoNode):
    r"""Proxy of C++ SoVRMLFog class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLFog_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLFog self) -> SoType"""
        return _coin.SoVRMLFog_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLFog_initClass()

    def __init__(self):
        r"""__init__(SoVRMLFog self) -> SoVRMLFog"""
        _coin.SoVRMLFog_swiginit(self, _coin.new_SoVRMLFog())
    fogType = property(_coin.SoVRMLFog_fogType_get, _coin.SoVRMLFog_fogType_set, doc=r"""fogType : SoSFString""")
    visibilityRange = property(_coin.SoVRMLFog_visibilityRange_get, _coin.SoVRMLFog_visibilityRange_set, doc=r"""visibilityRange : SoSFFloat""")
    color = property(_coin.SoVRMLFog_color_get, _coin.SoVRMLFog_color_set, doc=r"""color : SoSFColor""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLFog self, SoGLRenderAction action)"""
        return _coin.SoVRMLFog_GLRender(self, action)

# Register SoVRMLFog in _coin:
_coin.SoVRMLFog_swigregister(SoVRMLFog)
class SoVRMLFontStyle(SoNode):
    r"""Proxy of C++ SoVRMLFontStyle class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLFontStyle_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLFontStyle self) -> SoType"""
        return _coin.SoVRMLFontStyle_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLFontStyle_initClass()

    def __init__(self):
        r"""__init__(SoVRMLFontStyle self) -> SoVRMLFontStyle"""
        _coin.SoVRMLFontStyle_swiginit(self, _coin.new_SoVRMLFontStyle())
    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 = property(_coin.SoVRMLFontStyle_size_get, _coin.SoVRMLFontStyle_size_set, doc=r"""size : SoSFFloat""")
    family = property(_coin.SoVRMLFontStyle_family_get, _coin.SoVRMLFontStyle_family_set, doc=r"""family : SoMFString""")
    style = property(_coin.SoVRMLFontStyle_style_get, _coin.SoVRMLFontStyle_style_set, doc=r"""style : SoMFString""")
    horizontal = property(_coin.SoVRMLFontStyle_horizontal_get, _coin.SoVRMLFontStyle_horizontal_set, doc=r"""horizontal : SoSFBool""")
    leftToRight = property(_coin.SoVRMLFontStyle_leftToRight_get, _coin.SoVRMLFontStyle_leftToRight_set, doc=r"""leftToRight : SoSFBool""")
    topToBottom = property(_coin.SoVRMLFontStyle_topToBottom_get, _coin.SoVRMLFontStyle_topToBottom_set, doc=r"""topToBottom : SoSFBool""")
    language = property(_coin.SoVRMLFontStyle_language_get, _coin.SoVRMLFontStyle_language_set, doc=r"""language : SoSFString""")
    justify = property(_coin.SoVRMLFontStyle_justify_get, _coin.SoVRMLFontStyle_justify_set, doc=r"""justify : SoMFString""")
    spacing = property(_coin.SoVRMLFontStyle_spacing_get, _coin.SoVRMLFontStyle_spacing_set, doc=r"""spacing : SoSFFloat""")

    def getFontName(self):
        r"""getFontName(SoVRMLFontStyle self) -> SbString"""
        return _coin.SoVRMLFontStyle_getFontName(self)

    def doAction(self, action):
        r"""doAction(SoVRMLFontStyle self, SoAction action)"""
        return _coin.SoVRMLFontStyle_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLFontStyle self, SoCallbackAction action)"""
        return _coin.SoVRMLFontStyle_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLFontStyle self, SoGLRenderAction action)"""
        return _coin.SoVRMLFontStyle_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLFontStyle self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLFontStyle_getBoundingBox(self, action)

    def pick(self, action):
        r"""pick(SoVRMLFontStyle self, SoPickAction action)"""
        return _coin.SoVRMLFontStyle_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLFontStyle self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLFontStyle_getPrimitiveCount(self, action)

# Register SoVRMLFontStyle in _coin:
_coin.SoVRMLFontStyle_swigregister(SoVRMLFontStyle)

def so_vrml_init():
    r"""so_vrml_init()"""
    return _coin.so_vrml_init()
class SoVRMLTexture(SoNode):
    r"""Proxy of C++ SoVRMLTexture class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTexture_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLTexture self) -> SoType"""
        return _coin.SoVRMLTexture_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLTexture_initClass()
    repeatS = property(_coin.SoVRMLTexture_repeatS_get, _coin.SoVRMLTexture_repeatS_set, doc=r"""repeatS : SoSFBool""")
    repeatT = property(_coin.SoVRMLTexture_repeatT_get, _coin.SoVRMLTexture_repeatT_set, doc=r"""repeatT : SoSFBool""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLTexture_GLRender(self, action)

# Register SoVRMLTexture in _coin:
_coin.SoVRMLTexture_swigregister(SoVRMLTexture)
class SoVRMLImageTexture(SoVRMLTexture):
    r"""Proxy of C++ SoVRMLImageTexture class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLImageTexture_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLImageTexture self) -> SoType"""
        return _coin.SoVRMLImageTexture_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLImageTexture_initClass()

    def __init__(self):
        r"""__init__(SoVRMLImageTexture self) -> SoVRMLImageTexture"""
        _coin.SoVRMLImageTexture_swiginit(self, _coin.new_SoVRMLImageTexture())
    url = property(_coin.SoVRMLImageTexture_url_get, _coin.SoVRMLImageTexture_url_set, doc=r"""url : SoMFString""")

    @staticmethod
    def setDelayFetchURL(onoff):
        r"""setDelayFetchURL(SbBool const onoff)"""
        return _coin.SoVRMLImageTexture_setDelayFetchURL(onoff)

    @staticmethod
    def setPrequalifyFileCallBack(cb, closure):
        r"""setPrequalifyFileCallBack(VRMLPrequalifyFileCallback * cb, void * closure)"""
        return _coin.SoVRMLImageTexture_setPrequalifyFileCallBack(cb, closure)

    def allowPrequalifyFile(self, enable):
        r"""allowPrequalifyFile(SoVRMLImageTexture self, SbBool enable)"""
        return _coin.SoVRMLImageTexture_allowPrequalifyFile(self, enable)

    def doAction(self, action):
        r"""doAction(SoVRMLImageTexture self, SoAction action)"""
        return _coin.SoVRMLImageTexture_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLImageTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLImageTexture_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoVRMLImageTexture self, SoCallbackAction action)"""
        return _coin.SoVRMLImageTexture_callback(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLImageTexture self, SoRayPickAction action)"""
        return _coin.SoVRMLImageTexture_rayPick(self, action)

    def setImage(self, image):
        r"""setImage(SoVRMLImageTexture self, SbImage image)"""
        return _coin.SoVRMLImageTexture_setImage(self, image)

    def getImage(self):
        r"""getImage(SoVRMLImageTexture self) -> SbImage"""
        return _coin.SoVRMLImageTexture_getImage(self)

    @staticmethod
    def setImageDataMaxAge(maxage):
        r"""setImageDataMaxAge(uint32_t const maxage)"""
        return _coin.SoVRMLImageTexture_setImageDataMaxAge(maxage)

# Register SoVRMLImageTexture in _coin:
_coin.SoVRMLImageTexture_swigregister(SoVRMLImageTexture)
class SoVRMLVertexShape(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLVertexShape class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexShape_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLVertexShape self) -> SoType"""
        return _coin.SoVRMLVertexShape_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLVertexShape_initClass()
    coord = property(_coin.SoVRMLVertexShape_coord_get, _coin.SoVRMLVertexShape_coord_set, doc=r"""coord : SoSFNode""")
    texCoord = property(_coin.SoVRMLVertexShape_texCoord_get, _coin.SoVRMLVertexShape_texCoord_set, doc=r"""texCoord : SoSFNode""")
    normal = property(_coin.SoVRMLVertexShape_normal_get, _coin.SoVRMLVertexShape_normal_set, doc=r"""normal : SoSFNode""")
    color = property(_coin.SoVRMLVertexShape_color_get, _coin.SoVRMLVertexShape_color_set, doc=r"""color : SoSFNode""")
    colorPerVertex = property(_coin.SoVRMLVertexShape_colorPerVertex_get, _coin.SoVRMLVertexShape_colorPerVertex_set, doc=r"""colorPerVertex : SoSFBool""")
    normalPerVertex = property(_coin.SoVRMLVertexShape_normalPerVertex_get, _coin.SoVRMLVertexShape_normalPerVertex_set, doc=r"""normalPerVertex : SoSFBool""")
    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):
        r"""
        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):
        r"""doAction(SoVRMLVertexShape self, SoAction action)"""
        return _coin.SoVRMLVertexShape_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLVertexShape self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexShape_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLVertexShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexShape_getBoundingBox(self, action)

    def callback(self, action):
        r"""callback(SoVRMLVertexShape self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexShape_callback(self, action)

    def pick(self, action):
        r"""pick(SoVRMLVertexShape self, SoPickAction action)"""
        return _coin.SoVRMLVertexShape_pick(self, action)

    def notify(self, list):
        r"""notify(SoVRMLVertexShape self, SoNotList list)"""
        return _coin.SoVRMLVertexShape_notify(self, list)

# Register SoVRMLVertexShape in _coin:
_coin.SoVRMLVertexShape_swigregister(SoVRMLVertexShape)
class SoVRMLIndexedShape(SoVRMLVertexShape):
    r"""Proxy of C++ SoVRMLIndexedShape class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedShape_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLIndexedShape self) -> SoType"""
        return _coin.SoVRMLIndexedShape_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLIndexedShape_initClass()
    coordIndex = property(_coin.SoVRMLIndexedShape_coordIndex_get, _coin.SoVRMLIndexedShape_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    colorIndex = property(_coin.SoVRMLIndexedShape_colorIndex_get, _coin.SoVRMLIndexedShape_colorIndex_set, doc=r"""colorIndex : SoMFInt32""")
    normalIndex = property(_coin.SoVRMLIndexedShape_normalIndex_get, _coin.SoVRMLIndexedShape_normalIndex_set, doc=r"""normalIndex : SoMFInt32""")
    texCoordIndex = property(_coin.SoVRMLIndexedShape_texCoordIndex_get, _coin.SoVRMLIndexedShape_texCoordIndex_set, doc=r"""texCoordIndex : SoMFInt32""")

# Register SoVRMLIndexedShape in _coin:
_coin.SoVRMLIndexedShape_swigregister(SoVRMLIndexedShape)
class SoVRMLIndexedFaceSet(SoVRMLIndexedShape):
    r"""Proxy of C++ SoVRMLIndexedFaceSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedFaceSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLIndexedFaceSet self) -> SoType"""
        return _coin.SoVRMLIndexedFaceSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLIndexedFaceSet_initClass()

    def __init__(self):
        r"""__init__(SoVRMLIndexedFaceSet self) -> SoVRMLIndexedFaceSet"""
        _coin.SoVRMLIndexedFaceSet_swiginit(self, _coin.new_SoVRMLIndexedFaceSet())
    ccw = property(_coin.SoVRMLIndexedFaceSet_ccw_get, _coin.SoVRMLIndexedFaceSet_ccw_set, doc=r"""ccw : SoSFBool""")
    solid = property(_coin.SoVRMLIndexedFaceSet_solid_get, _coin.SoVRMLIndexedFaceSet_solid_set, doc=r"""solid : SoSFBool""")
    convex = property(_coin.SoVRMLIndexedFaceSet_convex_get, _coin.SoVRMLIndexedFaceSet_convex_set, doc=r"""convex : SoSFBool""")
    creaseAngle = property(_coin.SoVRMLIndexedFaceSet_creaseAngle_get, _coin.SoVRMLIndexedFaceSet_creaseAngle_set, doc=r"""creaseAngle : SoSFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLIndexedFaceSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLIndexedFaceSet_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLIndexedFaceSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLIndexedFaceSet_getPrimitiveCount(self, action)

    def generateDefaultNormals(self, *args):
        r"""
        generateDefaultNormals(SoVRMLIndexedFaceSet self, SoState s, SoNormalBundle nb) -> SbBool
        generateDefaultNormals(SoVRMLIndexedFaceSet self, SoState state, SoNormalCache nc) -> SbBool
        """
        return _coin.SoVRMLIndexedFaceSet_generateDefaultNormals(self, *args)

# Register SoVRMLIndexedFaceSet in _coin:
_coin.SoVRMLIndexedFaceSet_swigregister(SoVRMLIndexedFaceSet)
class SoVRMLVertexLine(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLVertexLine class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexLine_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLVertexLine self) -> SoType"""
        return _coin.SoVRMLVertexLine_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLVertexLine_initClass()
    coord = property(_coin.SoVRMLVertexLine_coord_get, _coin.SoVRMLVertexLine_coord_set, doc=r"""coord : SoSFNode""")
    color = property(_coin.SoVRMLVertexLine_color_get, _coin.SoVRMLVertexLine_color_set, doc=r"""color : SoSFNode""")
    colorPerVertex = property(_coin.SoVRMLVertexLine_colorPerVertex_get, _coin.SoVRMLVertexLine_colorPerVertex_set, doc=r"""colorPerVertex : SoSFBool""")

    def doAction(self, action):
        r"""doAction(SoVRMLVertexLine self, SoAction action)"""
        return _coin.SoVRMLVertexLine_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLVertexLine self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexLine_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLVertexLine self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexLine_getBoundingBox(self, action)

    def callback(self, action):
        r"""callback(SoVRMLVertexLine self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexLine_callback(self, action)

    def pick(self, action):
        r"""pick(SoVRMLVertexLine self, SoPickAction action)"""
        return _coin.SoVRMLVertexLine_pick(self, action)

    def notify(self, list):
        r"""notify(SoVRMLVertexLine self, SoNotList list)"""
        return _coin.SoVRMLVertexLine_notify(self, list)

# Register SoVRMLVertexLine in _coin:
_coin.SoVRMLVertexLine_swigregister(SoVRMLVertexLine)
class SoVRMLIndexedLine(SoVRMLVertexLine):
    r"""Proxy of C++ SoVRMLIndexedLine class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedLine_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLIndexedLine self) -> SoType"""
        return _coin.SoVRMLIndexedLine_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLIndexedLine_initClass()
    coordIndex = property(_coin.SoVRMLIndexedLine_coordIndex_get, _coin.SoVRMLIndexedLine_coordIndex_set, doc=r"""coordIndex : SoMFInt32""")
    colorIndex = property(_coin.SoVRMLIndexedLine_colorIndex_get, _coin.SoVRMLIndexedLine_colorIndex_set, doc=r"""colorIndex : SoMFInt32""")

# Register SoVRMLIndexedLine in _coin:
_coin.SoVRMLIndexedLine_swigregister(SoVRMLIndexedLine)
class SoVRMLIndexedLineSet(SoVRMLIndexedLine):
    r"""Proxy of C++ SoVRMLIndexedLineSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLIndexedLineSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLIndexedLineSet self) -> SoType"""
        return _coin.SoVRMLIndexedLineSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLIndexedLineSet_initClass()

    def __init__(self):
        r"""__init__(SoVRMLIndexedLineSet self) -> SoVRMLIndexedLineSet"""
        _coin.SoVRMLIndexedLineSet_swiginit(self, _coin.new_SoVRMLIndexedLineSet())

    def GLRender(self, action):
        r"""GLRender(SoVRMLIndexedLineSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLIndexedLineSet_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLIndexedLineSet self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLIndexedLineSet_getPrimitiveCount(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLIndexedLineSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLIndexedLineSet_getBoundingBox(self, action)

# Register SoVRMLIndexedLineSet in _coin:
_coin.SoVRMLIndexedLineSet_swigregister(SoVRMLIndexedLineSet)
class SoVRMLInline(SoNode):
    r"""Proxy of C++ SoVRMLInline class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLInline_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLInline self) -> SoType"""
        return _coin.SoVRMLInline_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLInline_initClass()

    def __init__(self):
        r"""__init__(SoVRMLInline self) -> SoVRMLInline"""
        _coin.SoVRMLInline_swiginit(self, _coin.new_SoVRMLInline())
    NEVER = _coin.SoVRMLInline_NEVER
    
    UNTIL_LOADED = _coin.SoVRMLInline_UNTIL_LOADED
    
    ALWAYS = _coin.SoVRMLInline_ALWAYS
    
    bboxCenter = property(_coin.SoVRMLInline_bboxCenter_get, _coin.SoVRMLInline_bboxCenter_set, doc=r"""bboxCenter : SoSFVec3f""")
    bboxSize = property(_coin.SoVRMLInline_bboxSize_get, _coin.SoVRMLInline_bboxSize_set, doc=r"""bboxSize : SoSFVec3f""")
    url = property(_coin.SoVRMLInline_url_get, _coin.SoVRMLInline_url_set, doc=r"""url : SoMFString""")

    def setFullURLName(self, url):
        r"""setFullURLName(SoVRMLInline self, SbString url)"""
        return _coin.SoVRMLInline_setFullURLName(self, url)

    def getFullURLName(self):
        r"""getFullURLName(SoVRMLInline self) -> SbString"""
        return _coin.SoVRMLInline_getFullURLName(self)

    def copyChildren(self):
        r"""copyChildren(SoVRMLInline self) -> SoGroup"""
        return _coin.SoVRMLInline_copyChildren(self)

    def requestURLData(self):
        r"""requestURLData(SoVRMLInline self)"""
        return _coin.SoVRMLInline_requestURLData(self)

    def isURLDataRequested(self):
        r"""isURLDataRequested(SoVRMLInline self) -> SbBool"""
        return _coin.SoVRMLInline_isURLDataRequested(self)

    def isURLDataHere(self):
        r"""isURLDataHere(SoVRMLInline self) -> SbBool"""
        return _coin.SoVRMLInline_isURLDataHere(self)

    def cancelURLDataRequest(self):
        r"""cancelURLDataRequest(SoVRMLInline self)"""
        return _coin.SoVRMLInline_cancelURLDataRequest(self)

    def setChildData(self, urlData):
        r"""setChildData(SoVRMLInline self, SoNode urlData)"""
        return _coin.SoVRMLInline_setChildData(self, urlData)

    def getChildData(self):
        r"""getChildData(SoVRMLInline self) -> SoNode"""
        return _coin.SoVRMLInline_getChildData(self)

    @staticmethod
    def setFetchURLCallBack(f, closure):
        r"""setFetchURLCallBack(SoVRMLInlineFetchURLCB * f, void * closure)"""
        return _coin.SoVRMLInline_setFetchURLCallBack(f, closure)

    @staticmethod
    def setBoundingBoxVisibility(b):
        r"""setBoundingBoxVisibility(SoVRMLInline::BboxVisibility b)"""
        return _coin.SoVRMLInline_setBoundingBoxVisibility(b)

    @staticmethod
    def getBoundingBoxVisibility():
        r"""getBoundingBoxVisibility() -> SoVRMLInline::BboxVisibility"""
        return _coin.SoVRMLInline_getBoundingBoxVisibility()

    @staticmethod
    def setBoundingBoxColor(color):
        r"""setBoundingBoxColor(SbColor color)"""
        return _coin.SoVRMLInline_setBoundingBoxColor(color)

    @staticmethod
    def getBoundingBoxColor():
        r"""getBoundingBoxColor() -> SbColor"""
        return _coin.SoVRMLInline_getBoundingBoxColor()

    @staticmethod
    def setReadAsSoFile(enable):
        r"""setReadAsSoFile(SbBool enable)"""
        return _coin.SoVRMLInline_setReadAsSoFile(enable)

    @staticmethod
    def getReadAsSoFile():
        r"""getReadAsSoFile() -> SbBool"""
        return _coin.SoVRMLInline_getReadAsSoFile()

    def doAction(self, action):
        r"""doAction(SoVRMLInline self, SoAction action)"""
        return _coin.SoVRMLInline_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLInline self, SoCallbackAction action)"""
        return _coin.SoVRMLInline_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLInline self, SoGLRenderAction action)"""
        return _coin.SoVRMLInline_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLInline self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLInline_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoVRMLInline self, SoGetMatrixAction action)"""
        return _coin.SoVRMLInline_getMatrix(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoVRMLInline self, SoHandleEventAction action)"""
        return _coin.SoVRMLInline_handleEvent(self, action)

    def search(self, action):
        r"""search(SoVRMLInline self, SoSearchAction action)"""
        return _coin.SoVRMLInline_search(self, action)

    def pick(self, action):
        r"""pick(SoVRMLInline self, SoPickAction action)"""
        return _coin.SoVRMLInline_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLInline self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLInline_getPrimitiveCount(self, action)

    def getChildren(self):
        r"""getChildren(SoVRMLInline self) -> SoChildList"""
        return _coin.SoVRMLInline_getChildren(self)

# Register SoVRMLInline in _coin:
_coin.SoVRMLInline_swigregister(SoVRMLInline)
class SoVRMLLOD(SoGroup):
    r"""Proxy of C++ SoVRMLLOD class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLLOD_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLLOD self) -> SoType"""
        return _coin.SoVRMLLOD_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLLOD_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLLOD self) -> SoVRMLLOD
        __init__(SoVRMLLOD self, int levels) -> SoVRMLLOD
        """
        _coin.SoVRMLLOD_swiginit(self, _coin.new_SoVRMLLOD(*args))
    range = property(_coin.SoVRMLLOD_range_get, _coin.SoVRMLLOD_range_set, doc=r"""range : SoMFFloat""")
    center = property(_coin.SoVRMLLOD_center_get, _coin.SoVRMLLOD_center_set, doc=r"""center : SoSFVec3f""")
    level = property(_coin.SoVRMLLOD_level_get, _coin.SoVRMLLOD_level_set, doc=r"""level : SoMFNode""")

    def affectsState(self):
        r"""affectsState(SoVRMLLOD self) -> SbBool"""
        return _coin.SoVRMLLOD_affectsState(self)

    def addLevel(self, level):
        r"""addLevel(SoVRMLLOD self, SoNode level)"""
        return _coin.SoVRMLLOD_addLevel(self, level)

    def insertLevel(self, level, idx):
        r"""insertLevel(SoVRMLLOD self, SoNode level, int idx)"""
        return _coin.SoVRMLLOD_insertLevel(self, level, idx)

    def getLevel(self, idx):
        r"""getLevel(SoVRMLLOD self, int idx) -> SoNode"""
        return _coin.SoVRMLLOD_getLevel(self, idx)

    def findLevel(self, level):
        r"""findLevel(SoVRMLLOD self, SoNode level) -> int"""
        return _coin.SoVRMLLOD_findLevel(self, level)

    def getNumLevels(self):
        r"""getNumLevels(SoVRMLLOD self) -> int"""
        return _coin.SoVRMLLOD_getNumLevels(self)

    def removeLevel(self, *args):
        r"""
        removeLevel(SoVRMLLOD self, int idx)
        removeLevel(SoVRMLLOD self, SoNode level)
        """
        return _coin.SoVRMLLOD_removeLevel(self, *args)

    def removeAllLevels(self):
        r"""removeAllLevels(SoVRMLLOD self)"""
        return _coin.SoVRMLLOD_removeAllLevels(self)

    def replaceLevel(self, *args):
        r"""
        replaceLevel(SoVRMLLOD self, int idx, SoNode level)
        replaceLevel(SoVRMLLOD self, SoNode old, SoNode level)
        """
        return _coin.SoVRMLLOD_replaceLevel(self, *args)

    def doAction(self, action):
        r"""doAction(SoVRMLLOD self, SoAction action)"""
        return _coin.SoVRMLLOD_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLLOD self, SoCallbackAction action)"""
        return _coin.SoVRMLLOD_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLLOD self, SoRayPickAction action)"""
        return _coin.SoVRMLLOD_rayPick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLLOD self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLLOD_getBoundingBox(self, action)

    def search(self, action):
        r"""search(SoVRMLLOD self, SoSearchAction action)"""
        return _coin.SoVRMLLOD_search(self, action)

    def write(self, action):
        r"""write(SoVRMLLOD self, SoWriteAction action)"""
        return _coin.SoVRMLLOD_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLLOD self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLLOD_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoVRMLLOD self, SoAudioRenderAction action)"""
        return _coin.SoVRMLLOD_audioRender(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action):
        r"""GLRenderInPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderInPath(self, action)

    def GLRenderOffPath(self, action):
        r"""GLRenderOffPath(SoVRMLLOD self, SoGLRenderAction action)"""
        return _coin.SoVRMLLOD_GLRenderOffPath(self, action)

    def addChild(self, child):
        r"""addChild(SoVRMLLOD self, SoNode child)"""
        return _coin.SoVRMLLOD_addChild(self, child)

    def insertChild(self, child, idx):
        r"""insertChild(SoVRMLLOD self, SoNode child, int idx)"""
        return _coin.SoVRMLLOD_insertChild(self, child, idx)

    def getChild(self, idx):
        r"""getChild(SoVRMLLOD self, int idx) -> SoNode"""
        return _coin.SoVRMLLOD_getChild(self, idx)

    def findChild(self, child):
        r"""findChild(SoVRMLLOD self, SoNode child) -> int"""
        return _coin.SoVRMLLOD_findChild(self, child)

    def getNumChildren(self):
        r"""getNumChildren(SoVRMLLOD self) -> int"""
        return _coin.SoVRMLLOD_getNumChildren(self)

    def removeChild(self, *args):
        r"""
        removeChild(SoVRMLLOD self, int idx)
        removeChild(SoVRMLLOD self, SoNode child)
        """
        return _coin.SoVRMLLOD_removeChild(self, *args)

    def removeAllChildren(self):
        r"""removeAllChildren(SoVRMLLOD self)"""
        return _coin.SoVRMLLOD_removeAllChildren(self)

    def replaceChild(self, *args):
        r"""
        replaceChild(SoVRMLLOD self, int idx, SoNode child)
        replaceChild(SoVRMLLOD self, SoNode old, SoNode child)
        """
        return _coin.SoVRMLLOD_replaceChild(self, *args)

    def getChildren(self):
        r"""getChildren(SoVRMLLOD self) -> SoChildList"""
        return _coin.SoVRMLLOD_getChildren(self)

# Register SoVRMLLOD in _coin:
_coin.SoVRMLLOD_swigregister(SoVRMLLOD)
class SoVRMLMaterial(SoNode):
    r"""Proxy of C++ SoVRMLMaterial class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLMaterial_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLMaterial self) -> SoType"""
        return _coin.SoVRMLMaterial_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLMaterial_initClass()

    def __init__(self):
        r"""__init__(SoVRMLMaterial self) -> SoVRMLMaterial"""
        _coin.SoVRMLMaterial_swiginit(self, _coin.new_SoVRMLMaterial())
    diffuseColor = property(_coin.SoVRMLMaterial_diffuseColor_get, _coin.SoVRMLMaterial_diffuseColor_set, doc=r"""diffuseColor : SoSFColor""")
    ambientIntensity = property(_coin.SoVRMLMaterial_ambientIntensity_get, _coin.SoVRMLMaterial_ambientIntensity_set, doc=r"""ambientIntensity : SoSFFloat""")
    specularColor = property(_coin.SoVRMLMaterial_specularColor_get, _coin.SoVRMLMaterial_specularColor_set, doc=r"""specularColor : SoSFColor""")
    emissiveColor = property(_coin.SoVRMLMaterial_emissiveColor_get, _coin.SoVRMLMaterial_emissiveColor_set, doc=r"""emissiveColor : SoSFColor""")
    shininess = property(_coin.SoVRMLMaterial_shininess_get, _coin.SoVRMLMaterial_shininess_set, doc=r"""shininess : SoSFFloat""")
    transparency = property(_coin.SoVRMLMaterial_transparency_get, _coin.SoVRMLMaterial_transparency_set, doc=r"""transparency : SoSFFloat""")

    def doAction(self, action):
        r"""doAction(SoVRMLMaterial self, SoAction action)"""
        return _coin.SoVRMLMaterial_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLMaterial self, SoGLRenderAction action)"""
        return _coin.SoVRMLMaterial_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoVRMLMaterial self, SoCallbackAction action)"""
        return _coin.SoVRMLMaterial_callback(self, action)

# Register SoVRMLMaterial in _coin:
_coin.SoVRMLMaterial_swigregister(SoVRMLMaterial)
class SoVRMLMovieTexture(SoVRMLTexture):
    r"""Proxy of C++ SoVRMLMovieTexture class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLMovieTexture_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLMovieTexture self) -> SoType"""
        return _coin.SoVRMLMovieTexture_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLMovieTexture_initClass()

    def __init__(self):
        r"""__init__(SoVRMLMovieTexture self) -> SoVRMLMovieTexture"""
        _coin.SoVRMLMovieTexture_swiginit(self, _coin.new_SoVRMLMovieTexture())
    loop = property(_coin.SoVRMLMovieTexture_loop_get, _coin.SoVRMLMovieTexture_loop_set, doc=r"""loop : SoSFBool""")
    speed = property(_coin.SoVRMLMovieTexture_speed_get, _coin.SoVRMLMovieTexture_speed_set, doc=r"""speed : SoSFFloat""")
    startTime = property(_coin.SoVRMLMovieTexture_startTime_get, _coin.SoVRMLMovieTexture_startTime_set, doc=r"""startTime : SoSFTime""")
    stopTime = property(_coin.SoVRMLMovieTexture_stopTime_get, _coin.SoVRMLMovieTexture_stopTime_set, doc=r"""stopTime : SoSFTime""")
    pauseTime = property(_coin.SoVRMLMovieTexture_pauseTime_get, _coin.SoVRMLMovieTexture_pauseTime_set, doc=r"""pauseTime : SoSFTime""")
    resumeTime = property(_coin.SoVRMLMovieTexture_resumeTime_get, _coin.SoVRMLMovieTexture_resumeTime_set, doc=r"""resumeTime : SoSFTime""")
    url = property(_coin.SoVRMLMovieTexture_url_get, _coin.SoVRMLMovieTexture_url_set, doc=r"""url : SoMFString""")
    duration_changed = property(_coin.SoVRMLMovieTexture_duration_changed_get, _coin.SoVRMLMovieTexture_duration_changed_set, doc=r"""duration_changed : SoSFTime""")
    isActive = property(_coin.SoVRMLMovieTexture_isActive_get, _coin.SoVRMLMovieTexture_isActive_set, doc=r"""isActive : SoSFBool""")
    alpha = property(_coin.SoVRMLMovieTexture_alpha_get, _coin.SoVRMLMovieTexture_alpha_set, doc=r"""alpha : SoSFFloat""")
    model = property(_coin.SoVRMLMovieTexture_model_get, _coin.SoVRMLMovieTexture_model_set, doc=r"""model : SoSFEnum""")
    blendColor = property(_coin.SoVRMLMovieTexture_blendColor_get, _coin.SoVRMLMovieTexture_blendColor_set, doc=r"""blendColor : SoSFColor""")
    scaleTexCoord = property(_coin.SoVRMLMovieTexture_scaleTexCoord_get, _coin.SoVRMLMovieTexture_scaleTexCoord_set, doc=r"""scaleTexCoord : SoSFBool""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLMovieTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLMovieTexture_GLRender(self, action)

# Register SoVRMLMovieTexture in _coin:
_coin.SoVRMLMovieTexture_swigregister(SoVRMLMovieTexture)
class SoVRMLNavigationInfo(SoNode):
    r"""Proxy of C++ SoVRMLNavigationInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLNavigationInfo_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLNavigationInfo self) -> SoType"""
        return _coin.SoVRMLNavigationInfo_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLNavigationInfo_initClass()

    def __init__(self):
        r"""__init__(SoVRMLNavigationInfo self) -> SoVRMLNavigationInfo"""
        _coin.SoVRMLNavigationInfo_swiginit(self, _coin.new_SoVRMLNavigationInfo())
    type = property(_coin.SoVRMLNavigationInfo_type_get, _coin.SoVRMLNavigationInfo_type_set, doc=r"""type : SoMFString""")
    speed = property(_coin.SoVRMLNavigationInfo_speed_get, _coin.SoVRMLNavigationInfo_speed_set, doc=r"""speed : SoSFFloat""")
    avatarSize = property(_coin.SoVRMLNavigationInfo_avatarSize_get, _coin.SoVRMLNavigationInfo_avatarSize_set, doc=r"""avatarSize : SoMFFloat""")
    visibilityLimit = property(_coin.SoVRMLNavigationInfo_visibilityLimit_get, _coin.SoVRMLNavigationInfo_visibilityLimit_set, doc=r"""visibilityLimit : SoSFFloat""")
    headlight = property(_coin.SoVRMLNavigationInfo_headlight_get, _coin.SoVRMLNavigationInfo_headlight_set, doc=r"""headlight : SoSFBool""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLNavigationInfo self, SoGLRenderAction action)"""
        return _coin.SoVRMLNavigationInfo_GLRender(self, action)

# Register SoVRMLNavigationInfo in _coin:
_coin.SoVRMLNavigationInfo_swigregister(SoVRMLNavigationInfo)
class SoVRMLNormal(SoNode):
    r"""Proxy of C++ SoVRMLNormal class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLNormal_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLNormal self) -> SoType"""
        return _coin.SoVRMLNormal_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLNormal_initClass()

    def __init__(self):
        r"""__init__(SoVRMLNormal self) -> SoVRMLNormal"""
        _coin.SoVRMLNormal_swiginit(self, _coin.new_SoVRMLNormal())
    vector = property(_coin.SoVRMLNormal_vector_get, _coin.SoVRMLNormal_vector_set, doc=r"""vector : SoMFVec3f""")

    def doAction(self, action):
        r"""doAction(SoVRMLNormal self, SoAction action)"""
        return _coin.SoVRMLNormal_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLNormal self, SoGLRenderAction action)"""
        return _coin.SoVRMLNormal_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoVRMLNormal self, SoCallbackAction action)"""
        return _coin.SoVRMLNormal_callback(self, action)

    def pick(self, action):
        r"""pick(SoVRMLNormal self, SoPickAction action)"""
        return _coin.SoVRMLNormal_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLNormal self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLNormal_getPrimitiveCount(self, action)

# Register SoVRMLNormal in _coin:
_coin.SoVRMLNormal_swigregister(SoVRMLNormal)
class SoVRMLNormalInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLNormalInterpolator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLNormalInterpolator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLNormalInterpolator self) -> SoType"""
        return _coin.SoVRMLNormalInterpolator_getTypeId(self)

    def getOutputData(self):
        r"""getOutputData(SoVRMLNormalInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLNormalInterpolator_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVRMLNormalInterpolator_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLNormalInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLNormalInterpolator self) -> SoVRMLNormalInterpolator"""
        _coin.SoVRMLNormalInterpolator_swiginit(self, _coin.new_SoVRMLNormalInterpolator())
    keyValue = property(_coin.SoVRMLNormalInterpolator_keyValue_get, _coin.SoVRMLNormalInterpolator_keyValue_set, doc=r"""keyValue : SoMFVec3f""")
    value_changed = property(_coin.SoVRMLNormalInterpolator_value_changed_get, _coin.SoVRMLNormalInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLNormalInterpolator in _coin:
_coin.SoVRMLNormalInterpolator_swigregister(SoVRMLNormalInterpolator)
class SoVRMLOrientationInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLOrientationInterpolator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLOrientationInterpolator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLOrientationInterpolator self) -> SoType"""
        return _coin.SoVRMLOrientationInterpolator_getTypeId(self)

    def getOutputData(self):
        r"""getOutputData(SoVRMLOrientationInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLOrientationInterpolator_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVRMLOrientationInterpolator_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLOrientationInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLOrientationInterpolator self) -> SoVRMLOrientationInterpolator"""
        _coin.SoVRMLOrientationInterpolator_swiginit(self, _coin.new_SoVRMLOrientationInterpolator())
    keyValue = property(_coin.SoVRMLOrientationInterpolator_keyValue_get, _coin.SoVRMLOrientationInterpolator_keyValue_set, doc=r"""keyValue : SoMFRotation""")
    value_changed = property(_coin.SoVRMLOrientationInterpolator_value_changed_get, _coin.SoVRMLOrientationInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLOrientationInterpolator in _coin:
_coin.SoVRMLOrientationInterpolator_swigregister(SoVRMLOrientationInterpolator)
class SoVRMLPixelTexture(SoVRMLTexture):
    r"""Proxy of C++ SoVRMLPixelTexture class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPixelTexture_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLPixelTexture self) -> SoType"""
        return _coin.SoVRMLPixelTexture_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLPixelTexture_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPixelTexture self) -> SoVRMLPixelTexture"""
        _coin.SoVRMLPixelTexture_swiginit(self, _coin.new_SoVRMLPixelTexture())
    image = property(_coin.SoVRMLPixelTexture_image_get, _coin.SoVRMLPixelTexture_image_set, doc=r"""image : SoSFImage""")

    def doAction(self, action):
        r"""doAction(SoVRMLPixelTexture self, SoAction action)"""
        return _coin.SoVRMLPixelTexture_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLPixelTexture self, SoGLRenderAction action)"""
        return _coin.SoVRMLPixelTexture_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoVRMLPixelTexture self, SoCallbackAction action)"""
        return _coin.SoVRMLPixelTexture_callback(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLPixelTexture self, SoRayPickAction action)"""
        return _coin.SoVRMLPixelTexture_rayPick(self, action)

# Register SoVRMLPixelTexture in _coin:
_coin.SoVRMLPixelTexture_swigregister(SoVRMLPixelTexture)
class SoVRMLPlaneSensor(SoVRMLDragSensor):
    r"""Proxy of C++ SoVRMLPlaneSensor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPlaneSensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLPlaneSensor self) -> SoType"""
        return _coin.SoVRMLPlaneSensor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLPlaneSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPlaneSensor self) -> SoVRMLPlaneSensor"""
        _coin.SoVRMLPlaneSensor_swiginit(self, _coin.new_SoVRMLPlaneSensor())
    minPosition = property(_coin.SoVRMLPlaneSensor_minPosition_get, _coin.SoVRMLPlaneSensor_minPosition_set, doc=r"""minPosition : SoSFVec2f""")
    maxPosition = property(_coin.SoVRMLPlaneSensor_maxPosition_get, _coin.SoVRMLPlaneSensor_maxPosition_set, doc=r"""maxPosition : SoSFVec2f""")
    offset = property(_coin.SoVRMLPlaneSensor_offset_get, _coin.SoVRMLPlaneSensor_offset_set, doc=r"""offset : SoSFVec3f""")
    translation_changed = property(_coin.SoVRMLPlaneSensor_translation_changed_get, _coin.SoVRMLPlaneSensor_translation_changed_set, doc=r"""translation_changed : SoSFVec3f""")

# Register SoVRMLPlaneSensor in _coin:
_coin.SoVRMLPlaneSensor_swigregister(SoVRMLPlaneSensor)
class SoVRMLPointLight(SoVRMLLight):
    r"""Proxy of C++ SoVRMLPointLight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPointLight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLPointLight self) -> SoType"""
        return _coin.SoVRMLPointLight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLPointLight_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPointLight self) -> SoVRMLPointLight"""
        _coin.SoVRMLPointLight_swiginit(self, _coin.new_SoVRMLPointLight())
    location = property(_coin.SoVRMLPointLight_location_get, _coin.SoVRMLPointLight_location_set, doc=r"""location : SoSFVec3f""")
    radius = property(_coin.SoVRMLPointLight_radius_get, _coin.SoVRMLPointLight_radius_set, doc=r"""radius : SoSFFloat""")
    attenuation = property(_coin.SoVRMLPointLight_attenuation_get, _coin.SoVRMLPointLight_attenuation_set, doc=r"""attenuation : SoSFVec3f""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLPointLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLPointLight_GLRender(self, action)

# Register SoVRMLPointLight in _coin:
_coin.SoVRMLPointLight_swigregister(SoVRMLPointLight)
class SoVRMLVertexPoint(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLVertexPoint class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLVertexPoint_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLVertexPoint self) -> SoType"""
        return _coin.SoVRMLVertexPoint_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLVertexPoint_initClass()
    coord = property(_coin.SoVRMLVertexPoint_coord_get, _coin.SoVRMLVertexPoint_coord_set, doc=r"""coord : SoSFNode""")
    color = property(_coin.SoVRMLVertexPoint_color_get, _coin.SoVRMLVertexPoint_color_set, doc=r"""color : SoSFNode""")

    def doAction(self, action):
        r"""doAction(SoVRMLVertexPoint self, SoAction action)"""
        return _coin.SoVRMLVertexPoint_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLVertexPoint self, SoGLRenderAction action)"""
        return _coin.SoVRMLVertexPoint_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLVertexPoint self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLVertexPoint_getBoundingBox(self, action)

    def callback(self, action):
        r"""callback(SoVRMLVertexPoint self, SoCallbackAction action)"""
        return _coin.SoVRMLVertexPoint_callback(self, action)

    def pick(self, action):
        r"""pick(SoVRMLVertexPoint self, SoPickAction action)"""
        return _coin.SoVRMLVertexPoint_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLVertexPoint self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLVertexPoint_getPrimitiveCount(self, action)

    def notify(self, list):
        r"""notify(SoVRMLVertexPoint self, SoNotList list)"""
        return _coin.SoVRMLVertexPoint_notify(self, list)

# Register SoVRMLVertexPoint in _coin:
_coin.SoVRMLVertexPoint_swigregister(SoVRMLVertexPoint)
class SoVRMLPointSet(SoVRMLVertexPoint):
    r"""Proxy of C++ SoVRMLPointSet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPointSet_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLPointSet self) -> SoType"""
        return _coin.SoVRMLPointSet_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLPointSet_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPointSet self) -> SoVRMLPointSet"""
        _coin.SoVRMLPointSet_swiginit(self, _coin.new_SoVRMLPointSet())

    def GLRender(self, action):
        r"""GLRender(SoVRMLPointSet self, SoGLRenderAction action)"""
        return _coin.SoVRMLPointSet_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLPointSet self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLPointSet_getBoundingBox(self, action)

# Register SoVRMLPointSet in _coin:
_coin.SoVRMLPointSet_swigregister(SoVRMLPointSet)
class SoVRMLPositionInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLPositionInterpolator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLPositionInterpolator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLPositionInterpolator self) -> SoType"""
        return _coin.SoVRMLPositionInterpolator_getTypeId(self)

    def getOutputData(self):
        r"""getOutputData(SoVRMLPositionInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLPositionInterpolator_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVRMLPositionInterpolator_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLPositionInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLPositionInterpolator self) -> SoVRMLPositionInterpolator"""
        _coin.SoVRMLPositionInterpolator_swiginit(self, _coin.new_SoVRMLPositionInterpolator())
    keyValue = property(_coin.SoVRMLPositionInterpolator_keyValue_get, _coin.SoVRMLPositionInterpolator_keyValue_set, doc=r"""keyValue : SoMFVec3f""")
    value_changed = property(_coin.SoVRMLPositionInterpolator_value_changed_get, _coin.SoVRMLPositionInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLPositionInterpolator in _coin:
_coin.SoVRMLPositionInterpolator_swigregister(SoVRMLPositionInterpolator)
class SoVRMLProximitySensor(SoNode):
    r"""Proxy of C++ SoVRMLProximitySensor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLProximitySensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLProximitySensor self) -> SoType"""
        return _coin.SoVRMLProximitySensor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLProximitySensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLProximitySensor self) -> SoVRMLProximitySensor"""
        _coin.SoVRMLProximitySensor_swiginit(self, _coin.new_SoVRMLProximitySensor())
    center = property(_coin.SoVRMLProximitySensor_center_get, _coin.SoVRMLProximitySensor_center_set, doc=r"""center : SoSFVec3f""")
    size = property(_coin.SoVRMLProximitySensor_size_get, _coin.SoVRMLProximitySensor_size_set, doc=r"""size : SoSFVec3f""")
    enabled = property(_coin.SoVRMLProximitySensor_enabled_get, _coin.SoVRMLProximitySensor_enabled_set, doc=r"""enabled : SoSFBool""")
    isActive = property(_coin.SoVRMLProximitySensor_isActive_get, _coin.SoVRMLProximitySensor_isActive_set, doc=r"""isActive : SoSFBool""")
    position_changed = property(_coin.SoVRMLProximitySensor_position_changed_get, _coin.SoVRMLProximitySensor_position_changed_set, doc=r"""position_changed : SoSFVec3f""")
    orientation_changed = property(_coin.SoVRMLProximitySensor_orientation_changed_get, _coin.SoVRMLProximitySensor_orientation_changed_set, doc=r"""orientation_changed : SoSFRotation""")
    enterTime = property(_coin.SoVRMLProximitySensor_enterTime_get, _coin.SoVRMLProximitySensor_enterTime_set, doc=r"""enterTime : SoSFTime""")
    exitTime = property(_coin.SoVRMLProximitySensor_exitTime_get, _coin.SoVRMLProximitySensor_exitTime_set, doc=r"""exitTime : SoSFTime""")

    def affectsState(self):
        r"""affectsState(SoVRMLProximitySensor self) -> SbBool"""
        return _coin.SoVRMLProximitySensor_affectsState(self)

    def doAction(self, action):
        r"""doAction(SoVRMLProximitySensor self, SoAction action)"""
        return _coin.SoVRMLProximitySensor_doAction(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLProximitySensor self, SoGLRenderAction action)"""
        return _coin.SoVRMLProximitySensor_GLRender(self, action)

    def callback(self, action):
        r"""callback(SoVRMLProximitySensor self, SoCallbackAction action)"""
        return _coin.SoVRMLProximitySensor_callback(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLProximitySensor self, SoRayPickAction action)"""
        return _coin.SoVRMLProximitySensor_rayPick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLProximitySensor self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLProximitySensor_getBoundingBox(self, action)

# Register SoVRMLProximitySensor in _coin:
_coin.SoVRMLProximitySensor_swigregister(SoVRMLProximitySensor)
class SoVRMLScalarInterpolator(SoVRMLInterpolator):
    r"""Proxy of C++ SoVRMLScalarInterpolator class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLScalarInterpolator_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLScalarInterpolator self) -> SoType"""
        return _coin.SoVRMLScalarInterpolator_getTypeId(self)

    def getOutputData(self):
        r"""getOutputData(SoVRMLScalarInterpolator self) -> SoEngineOutputData"""
        return _coin.SoVRMLScalarInterpolator_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVRMLScalarInterpolator_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLScalarInterpolator_initClass()

    def __init__(self):
        r"""__init__(SoVRMLScalarInterpolator self) -> SoVRMLScalarInterpolator"""
        _coin.SoVRMLScalarInterpolator_swiginit(self, _coin.new_SoVRMLScalarInterpolator())
    keyValue = property(_coin.SoVRMLScalarInterpolator_keyValue_get, _coin.SoVRMLScalarInterpolator_keyValue_set, doc=r"""keyValue : SoMFFloat""")
    value_changed = property(_coin.SoVRMLScalarInterpolator_value_changed_get, _coin.SoVRMLScalarInterpolator_value_changed_set, doc=r"""value_changed : SoEngineOutput""")

# Register SoVRMLScalarInterpolator in _coin:
_coin.SoVRMLScalarInterpolator_swigregister(SoVRMLScalarInterpolator)
class SoVRMLScript(SoNode):
    r"""Proxy of C++ SoVRMLScript class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLScript_initClass()

    def __init__(self):
        r"""__init__(SoVRMLScript self) -> SoVRMLScript"""
        _coin.SoVRMLScript_swiginit(self, _coin.new_SoVRMLScript())

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLScript_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLScript self) -> SoType"""
        return _coin.SoVRMLScript_getTypeId(self)
    url = property(_coin.SoVRMLScript_url_get, _coin.SoVRMLScript_url_set, doc=r"""url : SoMFString""")
    directOutput = property(_coin.SoVRMLScript_directOutput_get, _coin.SoVRMLScript_directOutput_set, doc=r"""directOutput : SoSFBool""")
    mustEvaluate = property(_coin.SoVRMLScript_mustEvaluate_get, _coin.SoVRMLScript_mustEvaluate_set, doc=r"""mustEvaluate : SoSFBool""")

    def doAction(self, action):
        r"""doAction(SoVRMLScript self, SoAction action)"""
        return _coin.SoVRMLScript_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLScript self, SoCallbackAction action)"""
        return _coin.SoVRMLScript_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLScript self, SoGLRenderAction action)"""
        return _coin.SoVRMLScript_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLScript self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLScript_getBoundingBox(self, action)

    def pick(self, action):
        r"""pick(SoVRMLScript self, SoPickAction action)"""
        return _coin.SoVRMLScript_pick(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoVRMLScript self, SoHandleEventAction action)"""
        return _coin.SoVRMLScript_handleEvent(self, action)

    def write(self, action):
        r"""write(SoVRMLScript self, SoWriteAction action)"""
        return _coin.SoVRMLScript_write(self, action)

    @staticmethod
    def setScriptEvaluateCB(cb, closure):
        r"""setScriptEvaluateCB(SoVRMLScriptEvaluateCB * cb, void * closure)"""
        return _coin.SoVRMLScript_setScriptEvaluateCB(cb, closure)

# Register SoVRMLScript in _coin:
_coin.SoVRMLScript_swigregister(SoVRMLScript)
class SoVRMLShape(SoNode):
    r"""Proxy of C++ SoVRMLShape class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLShape_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLShape self) -> SoType"""
        return _coin.SoVRMLShape_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLShape_initClass()

    def __init__(self):
        r"""__init__(SoVRMLShape self) -> SoVRMLShape"""
        _coin.SoVRMLShape_swiginit(self, _coin.new_SoVRMLShape())
    OFF = _coin.SoVRMLShape_OFF
    
    ON = _coin.SoVRMLShape_ON
    
    AUTO = _coin.SoVRMLShape_AUTO
    
    appearance = property(_coin.SoVRMLShape_appearance_get, _coin.SoVRMLShape_appearance_set, doc=r"""appearance : SoSFNode""")
    geometry = property(_coin.SoVRMLShape_geometry_get, _coin.SoVRMLShape_geometry_set, doc=r"""geometry : SoSFNode""")
    renderCaching = property(_coin.SoVRMLShape_renderCaching_get, _coin.SoVRMLShape_renderCaching_set, doc=r"""renderCaching : SoSFEnum""")
    boundingBoxCaching = property(_coin.SoVRMLShape_boundingBoxCaching_get, _coin.SoVRMLShape_boundingBoxCaching_set, doc=r"""boundingBoxCaching : SoSFEnum""")

    @staticmethod
    def setNumRenderCaches(num):
        r"""setNumRenderCaches(int num)"""
        return _coin.SoVRMLShape_setNumRenderCaches(num)

    @staticmethod
    def getNumRenderCaches():
        r"""getNumRenderCaches() -> int"""
        return _coin.SoVRMLShape_getNumRenderCaches()

    def affectsState(self):
        r"""affectsState(SoVRMLShape self) -> SbBool"""
        return _coin.SoVRMLShape_affectsState(self)

    def doAction(self, action):
        r"""doAction(SoVRMLShape self, SoAction action)"""
        return _coin.SoVRMLShape_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLShape self, SoCallbackAction action)"""
        return _coin.SoVRMLShape_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLShape self, SoGLRenderAction action)"""
        return _coin.SoVRMLShape_GLRender(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLShape self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLShape_getBoundingBox(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLShape self, SoRayPickAction action)"""
        return _coin.SoVRMLShape_rayPick(self, action)

    def search(self, action):
        r"""search(SoVRMLShape self, SoSearchAction action)"""
        return _coin.SoVRMLShape_search(self, action)

    def write(self, action):
        r"""write(SoVRMLShape self, SoWriteAction action)"""
        return _coin.SoVRMLShape_write(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLShape self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLShape_getPrimitiveCount(self, action)

    def getChildren(self):
        r"""getChildren(SoVRMLShape self) -> SoChildList"""
        return _coin.SoVRMLShape_getChildren(self)

    def notify(self, list):
        r"""notify(SoVRMLShape self, SoNotList list)"""
        return _coin.SoVRMLShape_notify(self, list)

    def copyContents(self, srcFrom, copyConn):
        r"""copyContents(SoVRMLShape self, SoFieldContainer srcFrom, SbBool copyConn)"""
        return _coin.SoVRMLShape_copyContents(self, srcFrom, copyConn)

# Register SoVRMLShape in _coin:
_coin.SoVRMLShape_swigregister(SoVRMLShape)
class SoVRMLSound(SoNode):
    r"""Proxy of C++ SoVRMLSound class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSound_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLSound self) -> SoType"""
        return _coin.SoVRMLSound_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLSound_initClass()

    def __init__(self):
        r"""__init__(SoVRMLSound self) -> SoVRMLSound"""
        _coin.SoVRMLSound_swiginit(self, _coin.new_SoVRMLSound())
    source = property(_coin.SoVRMLSound_source_get, _coin.SoVRMLSound_source_set, doc=r"""source : SoSFNode""")
    intensity = property(_coin.SoVRMLSound_intensity_get, _coin.SoVRMLSound_intensity_set, doc=r"""intensity : SoSFFloat""")
    priority = property(_coin.SoVRMLSound_priority_get, _coin.SoVRMLSound_priority_set, doc=r"""priority : SoSFFloat""")
    location = property(_coin.SoVRMLSound_location_get, _coin.SoVRMLSound_location_set, doc=r"""location : SoSFVec3f""")
    direction = property(_coin.SoVRMLSound_direction_get, _coin.SoVRMLSound_direction_set, doc=r"""direction : SoSFVec3f""")
    minFront = property(_coin.SoVRMLSound_minFront_get, _coin.SoVRMLSound_minFront_set, doc=r"""minFront : SoSFFloat""")
    maxFront = property(_coin.SoVRMLSound_maxFront_get, _coin.SoVRMLSound_maxFront_set, doc=r"""maxFront : SoSFFloat""")
    minBack = property(_coin.SoVRMLSound_minBack_get, _coin.SoVRMLSound_minBack_set, doc=r"""minBack : SoSFFloat""")
    maxBack = property(_coin.SoVRMLSound_maxBack_get, _coin.SoVRMLSound_maxBack_set, doc=r"""maxBack : SoSFFloat""")
    spatialize = property(_coin.SoVRMLSound_spatialize_get, _coin.SoVRMLSound_spatialize_set, doc=r"""spatialize : SoSFBool""")
    dopplerFactor = property(_coin.SoVRMLSound_dopplerFactor_get, _coin.SoVRMLSound_dopplerFactor_set, doc=r"""dopplerFactor : SoSFFloat""")
    dopplerVelocity = property(_coin.SoVRMLSound_dopplerVelocity_get, _coin.SoVRMLSound_dopplerVelocity_set, doc=r"""dopplerVelocity : SoSFFloat""")

    def setDopplerVelocity(self, velocity):
        r"""setDopplerVelocity(SoVRMLSound self, float velocity)"""
        return _coin.SoVRMLSound_setDopplerVelocity(self, velocity)

    def getDopplerVelocity(self):
        r"""getDopplerVelocity(SoVRMLSound self) -> float"""
        return _coin.SoVRMLSound_getDopplerVelocity(self)

    def setDopplerFactor(self, factor):
        r"""setDopplerFactor(SoVRMLSound self, float factor)"""
        return _coin.SoVRMLSound_setDopplerFactor(self, factor)

    def getDopplerFactor(self):
        r"""getDopplerFactor(SoVRMLSound self) -> float"""
        return _coin.SoVRMLSound_getDopplerFactor(self)

    def startPlaying(self, path, userdataptr):
        r"""startPlaying(SoVRMLSound self, SoPath path, void * userdataptr)"""
        return _coin.SoVRMLSound_startPlaying(self, path, userdataptr)

    def stopPlaying(self, path, userdataptr):
        r"""stopPlaying(SoVRMLSound self, SoPath path, void * userdataptr)"""
        return _coin.SoVRMLSound_stopPlaying(self, path, userdataptr)

    @staticmethod
    def setDefaultBufferingProperties(bufferLength, numBuffers, sleepTime):
        r"""setDefaultBufferingProperties(int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_setDefaultBufferingProperties(bufferLength, numBuffers, sleepTime)

    def setBufferingProperties(self, bufferLength, numBuffers, sleepTime):
        r"""setBufferingProperties(SoVRMLSound self, int bufferLength, int numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_setBufferingProperties(self, bufferLength, numBuffers, sleepTime)

    def getBufferingProperties(self, bufferLength, numBuffers, sleepTime):
        r"""getBufferingProperties(SoVRMLSound self, int & bufferLength, int & numBuffers, SbTime sleepTime)"""
        return _coin.SoVRMLSound_getBufferingProperties(self, bufferLength, numBuffers, sleepTime)

    def audioRender(self, action):
        r"""audioRender(SoVRMLSound self, SoAudioRenderAction action)"""
        return _coin.SoVRMLSound_audioRender(self, action)

# Register SoVRMLSound in _coin:
_coin.SoVRMLSound_swigregister(SoVRMLSound)
class SoVRMLSphere(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLSphere class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSphere_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLSphere self) -> SoType"""
        return _coin.SoVRMLSphere_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLSphere_initClass()

    def __init__(self):
        r"""__init__(SoVRMLSphere self) -> SoVRMLSphere"""
        _coin.SoVRMLSphere_swiginit(self, _coin.new_SoVRMLSphere())
    radius = property(_coin.SoVRMLSphere_radius_get, _coin.SoVRMLSphere_radius_set, doc=r"""radius : SoSFFloat""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLSphere self, SoGLRenderAction action)"""
        return _coin.SoVRMLSphere_GLRender(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLSphere self, SoRayPickAction action)"""
        return _coin.SoVRMLSphere_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLSphere self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLSphere_getPrimitiveCount(self, action)

# Register SoVRMLSphere in _coin:
_coin.SoVRMLSphere_swigregister(SoVRMLSphere)
class SoVRMLSphereSensor(SoVRMLDragSensor):
    r"""Proxy of C++ SoVRMLSphereSensor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSphereSensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLSphereSensor self) -> SoType"""
        return _coin.SoVRMLSphereSensor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLSphereSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLSphereSensor self) -> SoVRMLSphereSensor"""
        _coin.SoVRMLSphereSensor_swiginit(self, _coin.new_SoVRMLSphereSensor())
    offset = property(_coin.SoVRMLSphereSensor_offset_get, _coin.SoVRMLSphereSensor_offset_set, doc=r"""offset : SoSFRotation""")
    rotation_changed = property(_coin.SoVRMLSphereSensor_rotation_changed_get, _coin.SoVRMLSphereSensor_rotation_changed_set, doc=r"""rotation_changed : SoSFRotation""")

# Register SoVRMLSphereSensor in _coin:
_coin.SoVRMLSphereSensor_swigregister(SoVRMLSphereSensor)
class SoVRMLSpotLight(SoVRMLLight):
    r"""Proxy of C++ SoVRMLSpotLight class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSpotLight_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLSpotLight self) -> SoType"""
        return _coin.SoVRMLSpotLight_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLSpotLight_initClass()

    def __init__(self):
        r"""__init__(SoVRMLSpotLight self) -> SoVRMLSpotLight"""
        _coin.SoVRMLSpotLight_swiginit(self, _coin.new_SoVRMLSpotLight())
    location = property(_coin.SoVRMLSpotLight_location_get, _coin.SoVRMLSpotLight_location_set, doc=r"""location : SoSFVec3f""")
    direction = property(_coin.SoVRMLSpotLight_direction_get, _coin.SoVRMLSpotLight_direction_set, doc=r"""direction : SoSFVec3f""")
    beamWidth = property(_coin.SoVRMLSpotLight_beamWidth_get, _coin.SoVRMLSpotLight_beamWidth_set, doc=r"""beamWidth : SoSFFloat""")
    cutOffAngle = property(_coin.SoVRMLSpotLight_cutOffAngle_get, _coin.SoVRMLSpotLight_cutOffAngle_set, doc=r"""cutOffAngle : SoSFFloat""")
    radius = property(_coin.SoVRMLSpotLight_radius_get, _coin.SoVRMLSpotLight_radius_set, doc=r"""radius : SoSFFloat""")
    attenuation = property(_coin.SoVRMLSpotLight_attenuation_get, _coin.SoVRMLSpotLight_attenuation_set, doc=r"""attenuation : SoSFVec3f""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLSpotLight self, SoGLRenderAction action)"""
        return _coin.SoVRMLSpotLight_GLRender(self, action)

# Register SoVRMLSpotLight in _coin:
_coin.SoVRMLSpotLight_swigregister(SoVRMLSpotLight)
class SoVRMLSwitch(SoGroup):
    r"""Proxy of C++ SoVRMLSwitch class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLSwitch_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLSwitch self) -> SoType"""
        return _coin.SoVRMLSwitch_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLSwitch_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLSwitch self) -> SoVRMLSwitch
        __init__(SoVRMLSwitch self, int choices) -> SoVRMLSwitch
        """
        _coin.SoVRMLSwitch_swiginit(self, _coin.new_SoVRMLSwitch(*args))
    choice = property(_coin.SoVRMLSwitch_choice_get, _coin.SoVRMLSwitch_choice_set, doc=r"""choice : SoMFNode""")
    whichChoice = property(_coin.SoVRMLSwitch_whichChoice_get, _coin.SoVRMLSwitch_whichChoice_set, doc=r"""whichChoice : SoSFInt32""")

    def affectsState(self):
        r"""affectsState(SoVRMLSwitch self) -> SbBool"""
        return _coin.SoVRMLSwitch_affectsState(self)

    def addChoice(self, choice):
        r"""addChoice(SoVRMLSwitch self, SoNode choice)"""
        return _coin.SoVRMLSwitch_addChoice(self, choice)

    def insertChoice(self, choice, idx):
        r"""insertChoice(SoVRMLSwitch self, SoNode choice, int idx)"""
        return _coin.SoVRMLSwitch_insertChoice(self, choice, idx)

    def getChoice(self, idx):
        r"""getChoice(SoVRMLSwitch self, int idx) -> SoNode"""
        return _coin.SoVRMLSwitch_getChoice(self, idx)

    def findChoice(self, choice):
        r"""findChoice(SoVRMLSwitch self, SoNode choice) -> int"""
        return _coin.SoVRMLSwitch_findChoice(self, choice)

    def getNumChoices(self):
        r"""getNumChoices(SoVRMLSwitch self) -> int"""
        return _coin.SoVRMLSwitch_getNumChoices(self)

    def removeChoice(self, *args):
        r"""
        removeChoice(SoVRMLSwitch self, int idx)
        removeChoice(SoVRMLSwitch self, SoNode node)
        """
        return _coin.SoVRMLSwitch_removeChoice(self, *args)

    def removeAllChoices(self):
        r"""removeAllChoices(SoVRMLSwitch self)"""
        return _coin.SoVRMLSwitch_removeAllChoices(self)

    def replaceChoice(self, *args):
        r"""
        replaceChoice(SoVRMLSwitch self, int idx, SoNode choice)
        replaceChoice(SoVRMLSwitch self, SoNode old, SoNode choice)
        """
        return _coin.SoVRMLSwitch_replaceChoice(self, *args)

    def doAction(self, action):
        r"""doAction(SoVRMLSwitch self, SoAction action)"""
        return _coin.SoVRMLSwitch_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLSwitch self, SoCallbackAction action)"""
        return _coin.SoVRMLSwitch_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLSwitch self, SoGLRenderAction action)"""
        return _coin.SoVRMLSwitch_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoVRMLSwitch self, SoPickAction action)"""
        return _coin.SoVRMLSwitch_pick(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLSwitch self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLSwitch_getBoundingBox(self, action)

    def handleEvent(self, action):
        r"""handleEvent(SoVRMLSwitch self, SoHandleEventAction action)"""
        return _coin.SoVRMLSwitch_handleEvent(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoVRMLSwitch self, SoGetMatrixAction action)"""
        return _coin.SoVRMLSwitch_getMatrix(self, action)

    def search(self, action):
        r"""search(SoVRMLSwitch self, SoSearchAction action)"""
        return _coin.SoVRMLSwitch_search(self, action)

    def write(self, action):
        r"""write(SoVRMLSwitch self, SoWriteAction action)"""
        return _coin.SoVRMLSwitch_write(self, action)

    def audioRender(self, action):
        r"""audioRender(SoVRMLSwitch self, SoAudioRenderAction action)"""
        return _coin.SoVRMLSwitch_audioRender(self, action)

    def addChild(self, child):
        r"""addChild(SoVRMLSwitch self, SoNode child)"""
        return _coin.SoVRMLSwitch_addChild(self, child)

    def insertChild(self, child, idx):
        r"""insertChild(SoVRMLSwitch self, SoNode child, int idx)"""
        return _coin.SoVRMLSwitch_insertChild(self, child, idx)

    def getChild(self, idx):
        r"""getChild(SoVRMLSwitch self, int idx) -> SoNode"""
        return _coin.SoVRMLSwitch_getChild(self, idx)

    def findChild(self, child):
        r"""findChild(SoVRMLSwitch self, SoNode child) -> int"""
        return _coin.SoVRMLSwitch_findChild(self, child)

    def getNumChildren(self):
        r"""getNumChildren(SoVRMLSwitch self) -> int"""
        return _coin.SoVRMLSwitch_getNumChildren(self)

    def removeChild(self, *args):
        r"""
        removeChild(SoVRMLSwitch self, int idx)
        removeChild(SoVRMLSwitch self, SoNode child)
        """
        return _coin.SoVRMLSwitch_removeChild(self, *args)

    def removeAllChildren(self):
        r"""removeAllChildren(SoVRMLSwitch self)"""
        return _coin.SoVRMLSwitch_removeAllChildren(self)

    def replaceChild(self, *args):
        r"""
        replaceChild(SoVRMLSwitch self, int idx, SoNode node)
        replaceChild(SoVRMLSwitch self, SoNode old, SoNode node)
        """
        return _coin.SoVRMLSwitch_replaceChild(self, *args)

    def getChildren(self):
        r"""getChildren(SoVRMLSwitch self) -> SoChildList"""
        return _coin.SoVRMLSwitch_getChildren(self)

# Register SoVRMLSwitch in _coin:
_coin.SoVRMLSwitch_swigregister(SoVRMLSwitch)
class SoVRMLText(SoVRMLGeometry):
    r"""Proxy of C++ SoVRMLText class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLText_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLText self) -> SoType"""
        return _coin.SoVRMLText_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLText_initClass()

    def __init__(self):
        r"""__init__(SoVRMLText self) -> SoVRMLText"""
        _coin.SoVRMLText_swiginit(self, _coin.new_SoVRMLText())
    string = property(_coin.SoVRMLText_string_get, _coin.SoVRMLText_string_set, doc=r"""string : SoMFString""")
    fontStyle = property(_coin.SoVRMLText_fontStyle_get, _coin.SoVRMLText_fontStyle_set, doc=r"""fontStyle : SoSFNode""")
    maxExtent = property(_coin.SoVRMLText_maxExtent_get, _coin.SoVRMLText_maxExtent_set, doc=r"""maxExtent : SoSFFloat""")
    length = property(_coin.SoVRMLText_length_get, _coin.SoVRMLText_length_set, doc=r"""length : SoMFFloat""")
    BEGIN = _coin.SoVRMLText_BEGIN
    
    END = _coin.SoVRMLText_END
    
    MIDDLE = _coin.SoVRMLText_MIDDLE
    

    def GLRender(self, action):
        r"""GLRender(SoVRMLText self, SoGLRenderAction action)"""
        return _coin.SoVRMLText_GLRender(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLText self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLText_getPrimitiveCount(self, action)

    def notify(self, list):
        r"""notify(SoVRMLText self, SoNotList list)"""
        return _coin.SoVRMLText_notify(self, list)

    def getChildren(self):
        r"""getChildren(SoVRMLText self) -> SoChildList"""
        return _coin.SoVRMLText_getChildren(self)

# Register SoVRMLText in _coin:
_coin.SoVRMLText_swigregister(SoVRMLText)
class SoVRMLTextureCoordinate(SoNode):
    r"""Proxy of C++ SoVRMLTextureCoordinate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTextureCoordinate_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLTextureCoordinate self) -> SoType"""
        return _coin.SoVRMLTextureCoordinate_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLTextureCoordinate_initClass()

    def __init__(self):
        r"""__init__(SoVRMLTextureCoordinate self) -> SoVRMLTextureCoordinate"""
        _coin.SoVRMLTextureCoordinate_swiginit(self, _coin.new_SoVRMLTextureCoordinate())
    point = property(_coin.SoVRMLTextureCoordinate_point_get, _coin.SoVRMLTextureCoordinate_point_set, doc=r"""point : SoMFVec2f""")

    def doAction(self, action):
        r"""doAction(SoVRMLTextureCoordinate self, SoAction action)"""
        return _coin.SoVRMLTextureCoordinate_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLTextureCoordinate self, SoCallbackAction action)"""
        return _coin.SoVRMLTextureCoordinate_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLTextureCoordinate self, SoGLRenderAction action)"""
        return _coin.SoVRMLTextureCoordinate_GLRender(self, action)

    def pick(self, action):
        r"""pick(SoVRMLTextureCoordinate self, SoPickAction action)"""
        return _coin.SoVRMLTextureCoordinate_pick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLTextureCoordinate self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLTextureCoordinate_getPrimitiveCount(self, action)

# Register SoVRMLTextureCoordinate in _coin:
_coin.SoVRMLTextureCoordinate_swigregister(SoVRMLTextureCoordinate)
class SoVRMLTextureTransform(SoNode):
    r"""Proxy of C++ SoVRMLTextureTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTextureTransform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLTextureTransform self) -> SoType"""
        return _coin.SoVRMLTextureTransform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLTextureTransform_initClass()

    def __init__(self):
        r"""__init__(SoVRMLTextureTransform self) -> SoVRMLTextureTransform"""
        _coin.SoVRMLTextureTransform_swiginit(self, _coin.new_SoVRMLTextureTransform())
    translation = property(_coin.SoVRMLTextureTransform_translation_get, _coin.SoVRMLTextureTransform_translation_set, doc=r"""translation : SoSFVec2f""")
    rotation = property(_coin.SoVRMLTextureTransform_rotation_get, _coin.SoVRMLTextureTransform_rotation_set, doc=r"""rotation : SoSFFloat""")
    scale = property(_coin.SoVRMLTextureTransform_scale_get, _coin.SoVRMLTextureTransform_scale_set, doc=r"""scale : SoSFVec2f""")
    center = property(_coin.SoVRMLTextureTransform_center_get, _coin.SoVRMLTextureTransform_center_set, doc=r"""center : SoSFVec2f""")

    def doAction(self, action):
        r"""doAction(SoVRMLTextureTransform self, SoAction action)"""
        return _coin.SoVRMLTextureTransform_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLTextureTransform self, SoCallbackAction action)"""
        return _coin.SoVRMLTextureTransform_callback(self, action)

    def GLRender(self, action):
        r"""GLRender(SoVRMLTextureTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTextureTransform_GLRender(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoVRMLTextureTransform self, SoGetMatrixAction action)"""
        return _coin.SoVRMLTextureTransform_getMatrix(self, action)

    def pick(self, action):
        r"""pick(SoVRMLTextureTransform self, SoPickAction action)"""
        return _coin.SoVRMLTextureTransform_pick(self, action)

# Register SoVRMLTextureTransform in _coin:
_coin.SoVRMLTextureTransform_swigregister(SoVRMLTextureTransform)
class SoVRMLTimeSensor(SoNodeEngine):
    r"""Proxy of C++ SoVRMLTimeSensor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTimeSensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLTimeSensor self) -> SoType"""
        return _coin.SoVRMLTimeSensor_getTypeId(self)

    def getOutputData(self):
        r"""getOutputData(SoVRMLTimeSensor self) -> SoEngineOutputData"""
        return _coin.SoVRMLTimeSensor_getOutputData(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoVRMLTimeSensor_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLTimeSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLTimeSensor self) -> SoVRMLTimeSensor"""
        _coin.SoVRMLTimeSensor_swiginit(self, _coin.new_SoVRMLTimeSensor())
    cycleInterval = property(_coin.SoVRMLTimeSensor_cycleInterval_get, _coin.SoVRMLTimeSensor_cycleInterval_set, doc=r"""cycleInterval : SoSFTime""")
    enabled = property(_coin.SoVRMLTimeSensor_enabled_get, _coin.SoVRMLTimeSensor_enabled_set, doc=r"""enabled : SoSFBool""")
    loop = property(_coin.SoVRMLTimeSensor_loop_get, _coin.SoVRMLTimeSensor_loop_set, doc=r"""loop : SoSFBool""")
    startTime = property(_coin.SoVRMLTimeSensor_startTime_get, _coin.SoVRMLTimeSensor_startTime_set, doc=r"""startTime : SoSFTime""")
    stopTime = property(_coin.SoVRMLTimeSensor_stopTime_get, _coin.SoVRMLTimeSensor_stopTime_set, doc=r"""stopTime : SoSFTime""")

    def notify(self, list):
        r"""notify(SoVRMLTimeSensor self, SoNotList list)"""
        return _coin.SoVRMLTimeSensor_notify(self, list)

    def handleEvent(self, action):
        r"""handleEvent(SoVRMLTimeSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLTimeSensor_handleEvent(self, action)

    def write(self, action):
        r"""write(SoVRMLTimeSensor self, SoWriteAction action)"""
        return _coin.SoVRMLTimeSensor_write(self, action)
    cycleTime = property(_coin.SoVRMLTimeSensor_cycleTime_get, _coin.SoVRMLTimeSensor_cycleTime_set, doc=r"""cycleTime : SoEngineOutput""")
    fraction_changed = property(_coin.SoVRMLTimeSensor_fraction_changed_get, _coin.SoVRMLTimeSensor_fraction_changed_set, doc=r"""fraction_changed : SoEngineOutput""")
    isActive = property(_coin.SoVRMLTimeSensor_isActive_get, _coin.SoVRMLTimeSensor_isActive_set, doc=r"""isActive : SoEngineOutput""")
    time = property(_coin.SoVRMLTimeSensor_time_get, _coin.SoVRMLTimeSensor_time_set, doc=r"""time : SoEngineOutput""")

# Register SoVRMLTimeSensor in _coin:
_coin.SoVRMLTimeSensor_swigregister(SoVRMLTimeSensor)
class SoVRMLTouchSensor(SoNode):
    r"""Proxy of C++ SoVRMLTouchSensor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTouchSensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLTouchSensor self) -> SoType"""
        return _coin.SoVRMLTouchSensor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLTouchSensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLTouchSensor self) -> SoVRMLTouchSensor"""
        _coin.SoVRMLTouchSensor_swiginit(self, _coin.new_SoVRMLTouchSensor())
    enabled = property(_coin.SoVRMLTouchSensor_enabled_get, _coin.SoVRMLTouchSensor_enabled_set, doc=r"""enabled : SoSFBool""")
    hitNormal_changed = property(_coin.SoVRMLTouchSensor_hitNormal_changed_get, _coin.SoVRMLTouchSensor_hitNormal_changed_set, doc=r"""hitNormal_changed : SoSFVec3f""")
    hitPoint_changed = property(_coin.SoVRMLTouchSensor_hitPoint_changed_get, _coin.SoVRMLTouchSensor_hitPoint_changed_set, doc=r"""hitPoint_changed : SoSFVec3f""")
    hitTexCoord_changed = property(_coin.SoVRMLTouchSensor_hitTexCoord_changed_get, _coin.SoVRMLTouchSensor_hitTexCoord_changed_set, doc=r"""hitTexCoord_changed : SoSFVec2f""")
    isActive = property(_coin.SoVRMLTouchSensor_isActive_get, _coin.SoVRMLTouchSensor_isActive_set, doc=r"""isActive : SoSFBool""")
    isOver = property(_coin.SoVRMLTouchSensor_isOver_get, _coin.SoVRMLTouchSensor_isOver_set, doc=r"""isOver : SoSFBool""")
    touchTime = property(_coin.SoVRMLTouchSensor_touchTime_get, _coin.SoVRMLTouchSensor_touchTime_set, doc=r"""touchTime : SoSFTime""")

    def affectsState(self):
        r"""affectsState(SoVRMLTouchSensor self) -> SbBool"""
        return _coin.SoVRMLTouchSensor_affectsState(self)

    def handleEvent(self, action):
        r"""handleEvent(SoVRMLTouchSensor self, SoHandleEventAction action)"""
        return _coin.SoVRMLTouchSensor_handleEvent(self, action)

# Register SoVRMLTouchSensor in _coin:
_coin.SoVRMLTouchSensor_swigregister(SoVRMLTouchSensor)
class SoVRMLTransform(SoVRMLGroup):
    r"""Proxy of C++ SoVRMLTransform class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLTransform_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLTransform self) -> SoType"""
        return _coin.SoVRMLTransform_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLTransform_initClass()

    def __init__(self, *args):
        r"""
        __init__(SoVRMLTransform self) -> SoVRMLTransform
        __init__(SoVRMLTransform self, int children) -> SoVRMLTransform
        """
        _coin.SoVRMLTransform_swiginit(self, _coin.new_SoVRMLTransform(*args))
    translation = property(_coin.SoVRMLTransform_translation_get, _coin.SoVRMLTransform_translation_set, doc=r"""translation : SoSFVec3f""")
    rotation = property(_coin.SoVRMLTransform_rotation_get, _coin.SoVRMLTransform_rotation_set, doc=r"""rotation : SoSFRotation""")
    scale = property(_coin.SoVRMLTransform_scale_get, _coin.SoVRMLTransform_scale_set, doc=r"""scale : SoSFVec3f""")
    scaleOrientation = property(_coin.SoVRMLTransform_scaleOrientation_get, _coin.SoVRMLTransform_scaleOrientation_set, doc=r"""scaleOrientation : SoSFRotation""")
    center = property(_coin.SoVRMLTransform_center_get, _coin.SoVRMLTransform_center_set, doc=r"""center : SoSFVec3f""")

    def pointAt(self, srcFrom, destTo):
        r"""pointAt(SoVRMLTransform self, SbVec3f srcFrom, SbVec3f destTo)"""
        return _coin.SoVRMLTransform_pointAt(self, srcFrom, destTo)

    def getScaleSpaceMatrix(self, inverse):
        r"""getScaleSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getScaleSpaceMatrix(self, inverse)

    def getRotationSpaceMatrix(self, inverse):
        r"""getRotationSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getRotationSpaceMatrix(self, inverse)

    def getTranslationSpaceMatrix(self, inverse):
        r"""getTranslationSpaceMatrix(SoVRMLTransform self, SbMatrix inverse)"""
        return _coin.SoVRMLTransform_getTranslationSpaceMatrix(self, inverse)

    def multLeft(self):
        r"""multLeft(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_multLeft(self)

    def multRight(self):
        r"""multRight(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_multRight(self)

    def combineLeft(self, leftnode):
        r"""combineLeft(SoVRMLTransform self, SoVRMLTransform leftnode)"""
        return _coin.SoVRMLTransform_combineLeft(self, leftnode)

    def combineRight(self, rightnode):
        r"""combineRight(SoVRMLTransform self, SoVRMLTransform rightnode)"""
        return _coin.SoVRMLTransform_combineRight(self, rightnode)

    def setMatrix(self):
        r"""setMatrix(SoVRMLTransform self)"""
        return _coin.SoVRMLTransform_setMatrix(self)

    def recenter(self, newcenter):
        r"""recenter(SoVRMLTransform self, SbVec3f newcenter)"""
        return _coin.SoVRMLTransform_recenter(self, newcenter)

    def doAction(self, action):
        r"""doAction(SoVRMLTransform self, SoAction action)"""
        return _coin.SoVRMLTransform_doAction(self, action)

    def callback(self, action):
        r"""callback(SoVRMLTransform self, SoCallbackAction action)"""
        return _coin.SoVRMLTransform_callback(self, action)

    def getBoundingBox(self, action):
        r"""getBoundingBox(SoVRMLTransform self, SoGetBoundingBoxAction action)"""
        return _coin.SoVRMLTransform_getBoundingBox(self, action)

    def getMatrix(self, action):
        r"""getMatrix(SoVRMLTransform self, SoGetMatrixAction action)"""
        return _coin.SoVRMLTransform_getMatrix(self, action)

    def rayPick(self, action):
        r"""rayPick(SoVRMLTransform self, SoRayPickAction action)"""
        return _coin.SoVRMLTransform_rayPick(self, action)

    def getPrimitiveCount(self, action):
        r"""getPrimitiveCount(SoVRMLTransform self, SoGetPrimitiveCountAction action)"""
        return _coin.SoVRMLTransform_getPrimitiveCount(self, action)

    def audioRender(self, action):
        r"""audioRender(SoVRMLTransform self, SoAudioRenderAction action)"""
        return _coin.SoVRMLTransform_audioRender(self, action)

    def GLRenderBelowPath(self, action):
        r"""GLRenderBelowPath(SoVRMLTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTransform_GLRenderBelowPath(self, action)

    def GLRenderInPath(self, action):
        r"""GLRenderInPath(SoVRMLTransform self, SoGLRenderAction action)"""
        return _coin.SoVRMLTransform_GLRenderInPath(self, action)

    def notify(self, list):
        r"""notify(SoVRMLTransform self, SoNotList list)"""
        return _coin.SoVRMLTransform_notify(self, list)

# Register SoVRMLTransform in _coin:
_coin.SoVRMLTransform_swigregister(SoVRMLTransform)
class SoVRMLViewpoint(SoNode):
    r"""Proxy of C++ SoVRMLViewpoint class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLViewpoint_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLViewpoint self) -> SoType"""
        return _coin.SoVRMLViewpoint_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLViewpoint_initClass()

    def __init__(self):
        r"""__init__(SoVRMLViewpoint self) -> SoVRMLViewpoint"""
        _coin.SoVRMLViewpoint_swiginit(self, _coin.new_SoVRMLViewpoint())
    position = property(_coin.SoVRMLViewpoint_position_get, _coin.SoVRMLViewpoint_position_set, doc=r"""position : SoSFVec3f""")
    orientation = property(_coin.SoVRMLViewpoint_orientation_get, _coin.SoVRMLViewpoint_orientation_set, doc=r"""orientation : SoSFRotation""")
    fieldOfView = property(_coin.SoVRMLViewpoint_fieldOfView_get, _coin.SoVRMLViewpoint_fieldOfView_set, doc=r"""fieldOfView : SoSFFloat""")
    description = property(_coin.SoVRMLViewpoint_description_get, _coin.SoVRMLViewpoint_description_set, doc=r"""description : SoSFString""")
    jump = property(_coin.SoVRMLViewpoint_jump_get, _coin.SoVRMLViewpoint_jump_set, doc=r"""jump : SoSFBool""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLViewpoint self, SoGLRenderAction action)"""
        return _coin.SoVRMLViewpoint_GLRender(self, action)

# Register SoVRMLViewpoint in _coin:
_coin.SoVRMLViewpoint_swigregister(SoVRMLViewpoint)
class SoVRMLVisibilitySensor(SoNode):
    r"""Proxy of C++ SoVRMLVisibilitySensor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLVisibilitySensor_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLVisibilitySensor self) -> SoType"""
        return _coin.SoVRMLVisibilitySensor_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLVisibilitySensor_initClass()

    def __init__(self):
        r"""__init__(SoVRMLVisibilitySensor self) -> SoVRMLVisibilitySensor"""
        _coin.SoVRMLVisibilitySensor_swiginit(self, _coin.new_SoVRMLVisibilitySensor())
    center = property(_coin.SoVRMLVisibilitySensor_center_get, _coin.SoVRMLVisibilitySensor_center_set, doc=r"""center : SoSFVec3f""")
    size = property(_coin.SoVRMLVisibilitySensor_size_get, _coin.SoVRMLVisibilitySensor_size_set, doc=r"""size : SoSFVec3f""")
    enabled = property(_coin.SoVRMLVisibilitySensor_enabled_get, _coin.SoVRMLVisibilitySensor_enabled_set, doc=r"""enabled : SoSFBool""")
    enterTime = property(_coin.SoVRMLVisibilitySensor_enterTime_get, _coin.SoVRMLVisibilitySensor_enterTime_set, doc=r"""enterTime : SoSFTime""")
    exitTime = property(_coin.SoVRMLVisibilitySensor_exitTime_get, _coin.SoVRMLVisibilitySensor_exitTime_set, doc=r"""exitTime : SoSFTime""")
    isActive = property(_coin.SoVRMLVisibilitySensor_isActive_get, _coin.SoVRMLVisibilitySensor_isActive_set, doc=r"""isActive : SoSFBool""")

    def GLRender(self, action):
        r"""GLRender(SoVRMLVisibilitySensor self, SoGLRenderAction action)"""
        return _coin.SoVRMLVisibilitySensor_GLRender(self, action)

# Register SoVRMLVisibilitySensor in _coin:
_coin.SoVRMLVisibilitySensor_swigregister(SoVRMLVisibilitySensor)
class SoVRMLWorldInfo(SoNode):
    r"""Proxy of C++ SoVRMLWorldInfo class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoVRMLWorldInfo_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoVRMLWorldInfo self) -> SoType"""
        return _coin.SoVRMLWorldInfo_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoVRMLWorldInfo_initClass()

    def __init__(self):
        r"""__init__(SoVRMLWorldInfo self) -> SoVRMLWorldInfo"""
        _coin.SoVRMLWorldInfo_swiginit(self, _coin.new_SoVRMLWorldInfo())
    title = property(_coin.SoVRMLWorldInfo_title_get, _coin.SoVRMLWorldInfo_title_set, doc=r"""title : SoSFString""")
    info = property(_coin.SoVRMLWorldInfo_info_get, _coin.SoVRMLWorldInfo_info_set, doc=r"""info : SoMFString""")

# Register SoVRMLWorldInfo in _coin:
_coin.SoVRMLWorldInfo_swigregister(SoVRMLWorldInfo)
class SoEventManager(object):
    r"""Proxy of C++ SoEventManager class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(SoEventManager self) -> SoEventManager"""
        _coin.SoEventManager_swiginit(self, _coin.new_SoEventManager())
    __swig_destroy__ = _coin.delete_SoEventManager
    NO_NAVIGATION = _coin.SoEventManager_NO_NAVIGATION
    
    JUST_NAVIGATION = _coin.SoEventManager_JUST_NAVIGATION
    
    MIXED_NAVIGATION = _coin.SoEventManager_MIXED_NAVIGATION
    

    def setSceneGraph(self, sceneroot):
        r"""setSceneGraph(SoEventManager self, SoNode sceneroot)"""
        return _coin.SoEventManager_setSceneGraph(self, sceneroot)

    def getSceneGraph(self):
        r"""getSceneGraph(SoEventManager self) -> SoNode"""
        return _coin.SoEventManager_getSceneGraph(self)

    def setCamera(self, camera):
        r"""setCamera(SoEventManager self, SoCamera camera)"""
        return _coin.SoEventManager_setCamera(self, camera)

    def getCamera(self):
        r"""getCamera(SoEventManager self) -> SoCamera"""
        return _coin.SoEventManager_getCamera(self)

    def processEvent(self, event):
        r"""processEvent(SoEventManager self, SoEvent event) -> SbBool"""
        return _coin.SoEventManager_processEvent(self, event)

    def setNavigationState(self, state):
        r"""setNavigationState(SoEventManager self, SoEventManager::NavigationState state)"""
        return _coin.SoEventManager_setNavigationState(self, state)

    def getNavigationState(self):
        r"""getNavigationState(SoEventManager self) -> SoEventManager::NavigationState"""
        return _coin.SoEventManager_getNavigationState(self)

    def getNumSoScXMLStateMachines(self):
        r"""getNumSoScXMLStateMachines(SoEventManager self) -> int"""
        return _coin.SoEventManager_getNumSoScXMLStateMachines(self)

    def getSoScXMLStateMachine(self, idx):
        r"""getSoScXMLStateMachine(SoEventManager self, int idx) -> SoScXMLStateMachine"""
        return _coin.SoEventManager_getSoScXMLStateMachine(self, idx)

    def addSoScXMLStateMachine(self, sm):
        r"""addSoScXMLStateMachine(SoEventManager self, SoScXMLStateMachine sm)"""
        return _coin.SoEventManager_addSoScXMLStateMachine(self, sm)

    def removeSoScXMLStateMachine(self, sm):
        r"""removeSoScXMLStateMachine(SoEventManager self, SoScXMLStateMachine sm)"""
        return _coin.SoEventManager_removeSoScXMLStateMachine(self, sm)

    def setSize(self, newsize):
        r"""setSize(SoEventManager self, SbVec2s newsize)"""
        return _coin.SoEventManager_setSize(self, newsize)

    def setOrigin(self, newOrigin):
        r"""setOrigin(SoEventManager self, SbVec2s newOrigin)"""
        return _coin.SoEventManager_setOrigin(self, newOrigin)

    def setViewportRegion(self, newregion):
        r"""setViewportRegion(SoEventManager self, SbViewportRegion newregion)"""
        return _coin.SoEventManager_setViewportRegion(self, newregion)

    def getViewportRegion(self):
        r"""getViewportRegion(SoEventManager self) -> SbViewportRegion"""
        return _coin.SoEventManager_getViewportRegion(self)

    def setHandleEventAction(self, hea):
        r"""setHandleEventAction(SoEventManager self, SoHandleEventAction hea)"""
        return _coin.SoEventManager_setHandleEventAction(self, hea)

    def getHandleEventAction(self):
        r"""getHandleEventAction(SoEventManager self) -> SoHandleEventAction"""
        return _coin.SoEventManager_getHandleEventAction(self)

# Register SoEventManager in _coin:
_coin.SoEventManager_swigregister(SoEventManager)
class SoRenderManager(object):
    r"""Proxy of C++ SoRenderManager class."""

    thisown = 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):
        r"""__init__(SoRenderManager self) -> SoRenderManager"""
        _coin.SoRenderManager_swiginit(self, _coin.new_SoRenderManager())
    __swig_destroy__ = _coin.delete_SoRenderManager

    def render(self, *args):
        r"""
        render(SoRenderManager self, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        render(SoRenderManager self, SoGLRenderAction action, SbBool const initmatrices=1, SbBool const clearwindow=1, SbBool const clearzbuffer=1)
        """
        return _coin.SoRenderManager_render(self, *args)

    def addSuperimposition(self, *args):
        r"""addSuperimposition(SoRenderManager self, SoNode scene, uint32_t flags=SoRenderManager::Superimposition::AUTOREDRAW|SoRenderManager::Superimposition::ZBUFFERON|SoRenderManager::Superimposition::CLEARZBUFFER) -> SoRenderManager::Superimposition"""
        return _coin.SoRenderManager_addSuperimposition(self, *args)

    def removeSuperimposition(self, s):
        r"""removeSuperimposition(SoRenderManager self, SoRenderManager::Superimposition * s)"""
        return _coin.SoRenderManager_removeSuperimposition(self, s)

    def setSceneGraph(self, sceneroot):
        r"""setSceneGraph(SoRenderManager self, SoNode sceneroot)"""
        return _coin.SoRenderManager_setSceneGraph(self, sceneroot)

    def getSceneGraph(self):
        r"""getSceneGraph(SoRenderManager self) -> SoNode"""
        return _coin.SoRenderManager_getSceneGraph(self)

    def setCamera(self, camera):
        r"""setCamera(SoRenderManager self, SoCamera camera)"""
        return _coin.SoRenderManager_setCamera(self, camera)

    def getCamera(self):
        r"""getCamera(SoRenderManager self) -> SoCamera"""
        return _coin.SoRenderManager_getCamera(self)

    def setAutoClipping(self, autoclipping):
        r"""setAutoClipping(SoRenderManager self, SoRenderManager::AutoClippingStrategy autoclipping)"""
        return _coin.SoRenderManager_setAutoClipping(self, autoclipping)

    def attachRootSensor(self, sceneroot):
        r"""attachRootSensor(SoRenderManager self, SoNode sceneroot)"""
        return _coin.SoRenderManager_attachRootSensor(self, sceneroot)

    def attachClipSensor(self, sceneroot):
        r"""attachClipSensor(SoRenderManager self, SoNode sceneroot)"""
        return _coin.SoRenderManager_attachClipSensor(self, sceneroot)

    def detachRootSensor(self):
        r"""detachRootSensor(SoRenderManager self)"""
        return _coin.SoRenderManager_detachRootSensor(self)

    def detachClipSensor(self):
        r"""detachClipSensor(SoRenderManager self)"""
        return _coin.SoRenderManager_detachClipSensor(self)

    def getAutoClipping(self):
        r"""getAutoClipping(SoRenderManager self) -> SoRenderManager::AutoClippingStrategy"""
        return _coin.SoRenderManager_getAutoClipping(self)

    def setNearPlaneValue(self, value):
        r"""setNearPlaneValue(SoRenderManager self, float value)"""
        return _coin.SoRenderManager_setNearPlaneValue(self, value)

    def getNearPlaneValue(self):
        r"""getNearPlaneValue(SoRenderManager self) -> float"""
        return _coin.SoRenderManager_getNearPlaneValue(self)

    def setTexturesEnabled(self, onoff):
        r"""setTexturesEnabled(SoRenderManager self, SbBool const onoff)"""
        return _coin.SoRenderManager_setTexturesEnabled(self, onoff)

    def isTexturesEnabled(self):
        r"""isTexturesEnabled(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isTexturesEnabled(self)

    def setDoubleBuffer(self, enable):
        r"""setDoubleBuffer(SoRenderManager self, SbBool const enable)"""
        return _coin.SoRenderManager_setDoubleBuffer(self, enable)

    def isDoubleBuffer(self):
        r"""isDoubleBuffer(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isDoubleBuffer(self)

    def setRenderMode(self, mode):
        r"""setRenderMode(SoRenderManager self, SoRenderManager::RenderMode const mode)"""
        return _coin.SoRenderManager_setRenderMode(self, mode)

    def getRenderMode(self):
        r"""getRenderMode(SoRenderManager self) -> SoRenderManager::RenderMode"""
        return _coin.SoRenderManager_getRenderMode(self)

    def setStereoMode(self, mode):
        r"""setStereoMode(SoRenderManager self, SoRenderManager::StereoMode const mode)"""
        return _coin.SoRenderManager_setStereoMode(self, mode)

    def getStereoMode(self):
        r"""getStereoMode(SoRenderManager self) -> SoRenderManager::StereoMode"""
        return _coin.SoRenderManager_getStereoMode(self)

    def setStereoOffset(self, offset):
        r"""setStereoOffset(SoRenderManager self, float const offset)"""
        return _coin.SoRenderManager_setStereoOffset(self, offset)

    def getStereoOffset(self):
        r"""getStereoOffset(SoRenderManager self) -> float"""
        return _coin.SoRenderManager_getStereoOffset(self)

    def isAutoRedraw(self):
        r"""isAutoRedraw(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isAutoRedraw(self)

    def setRedrawPriority(self, priority):
        r"""setRedrawPriority(SoRenderManager self, uint32_t const priority)"""
        return _coin.SoRenderManager_setRedrawPriority(self, priority)

    def getRedrawPriority(self):
        r"""getRedrawPriority(SoRenderManager self) -> uint32_t"""
        return _coin.SoRenderManager_getRedrawPriority(self)

    @staticmethod
    def nodesensorCB(data, arg2):
        r"""nodesensorCB(void * data, SoSensor arg2)"""
        return _coin.SoRenderManager_nodesensorCB(data, arg2)

    @staticmethod
    def prerendercb(userdata, action):
        r"""prerendercb(void * userdata, SoGLRenderAction action)"""
        return _coin.SoRenderManager_prerendercb(userdata, action)

    def reinitialize(self):
        r"""reinitialize(SoRenderManager self)"""
        return _coin.SoRenderManager_reinitialize(self)

    def scheduleRedraw(self):
        r"""scheduleRedraw(SoRenderManager self)"""
        return _coin.SoRenderManager_scheduleRedraw(self)

    def setWindowSize(self, newsize):
        r"""setWindowSize(SoRenderManager self, SbVec2s newsize)"""
        return _coin.SoRenderManager_setWindowSize(self, newsize)

    def getWindowSize(self):
        r"""getWindowSize(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getWindowSize(self)

    def setSize(self, newsize):
        r"""setSize(SoRenderManager self, SbVec2s newsize)"""
        return _coin.SoRenderManager_setSize(self, newsize)

    def getSize(self):
        r"""getSize(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getSize(self)

    def setOrigin(self, newOrigin):
        r"""setOrigin(SoRenderManager self, SbVec2s newOrigin)"""
        return _coin.SoRenderManager_setOrigin(self, newOrigin)

    def getOrigin(self):
        r"""getOrigin(SoRenderManager self) -> SbVec2s"""
        return _coin.SoRenderManager_getOrigin(self)

    def setViewportRegion(self, newRegion):
        r"""setViewportRegion(SoRenderManager self, SbViewportRegion newRegion)"""
        return _coin.SoRenderManager_setViewportRegion(self, newRegion)

    def getViewportRegion(self):
        r"""getViewportRegion(SoRenderManager self) -> SbViewportRegion"""
        return _coin.SoRenderManager_getViewportRegion(self)

    def setBackgroundColor(self, color):
        r"""setBackgroundColor(SoRenderManager self, SbColor4f color)"""
        return _coin.SoRenderManager_setBackgroundColor(self, color)

    def getBackgroundColor(self):
        r"""getBackgroundColor(SoRenderManager self) -> SbColor4f"""
        return _coin.SoRenderManager_getBackgroundColor(self)

    def setBackgroundIndex(self, index):
        r"""setBackgroundIndex(SoRenderManager self, int const index)"""
        return _coin.SoRenderManager_setBackgroundIndex(self, index)

    def getBackgroundIndex(self):
        r"""getBackgroundIndex(SoRenderManager self) -> int"""
        return _coin.SoRenderManager_getBackgroundIndex(self)

    def setRGBMode(self, onOrOff):
        r"""setRGBMode(SoRenderManager self, SbBool const onOrOff)"""
        return _coin.SoRenderManager_setRGBMode(self, onOrOff)

    def isRGBMode(self):
        r"""isRGBMode(SoRenderManager self) -> SbBool"""
        return _coin.SoRenderManager_isRGBMode(self)

    def activate(self):
        r"""activate(SoRenderManager self)"""
        return _coin.SoRenderManager_activate(self)

    def deactivate(self):
        r"""deactivate(SoRenderManager self)"""
        return _coin.SoRenderManager_deactivate(self)

    def setAntialiasing(self, smoothing, numPasses):
        r"""setAntialiasing(SoRenderManager self, SbBool const smoothing, int const numPasses)"""
        return _coin.SoRenderManager_setAntialiasing(self, smoothing, numPasses)

    def getAntialiasing(self, smoothing, numPasses):
        r"""getAntialiasing(SoRenderManager self, SbBool & smoothing, int & numPasses)"""
        return _coin.SoRenderManager_getAntialiasing(self, smoothing, numPasses)

    def setGLRenderAction(self, action):
        r"""setGLRenderAction(SoRenderManager self, SoGLRenderAction action)"""
        return _coin.SoRenderManager_setGLRenderAction(self, action)

    def getGLRenderAction(self):
        r"""getGLRenderAction(SoRenderManager self) -> SoGLRenderAction"""
        return _coin.SoRenderManager_getGLRenderAction(self)

    def setAudioRenderAction(self, action):
        r"""setAudioRenderAction(SoRenderManager self, SoAudioRenderAction action)"""
        return _coin.SoRenderManager_setAudioRenderAction(self, action)

    def getAudioRenderAction(self):
        r"""getAudioRenderAction(SoRenderManager self) -> SoAudioRenderAction"""
        return _coin.SoRenderManager_getAudioRenderAction(self)

    @staticmethod
    def enableRealTimeUpdate(flag):
        r"""enableRealTimeUpdate(SbBool const flag)"""
        return _coin.SoRenderManager_enableRealTimeUpdate(flag)

    @staticmethod
    def isRealTimeUpdateEnabled():
        r"""isRealTimeUpdateEnabled() -> SbBool"""
        return _coin.SoRenderManager_isRealTimeUpdateEnabled()

    @staticmethod
    def getDefaultRedrawPriority():
        r"""getDefaultRedrawPriority() -> uint32_t"""
        return _coin.SoRenderManager_getDefaultRedrawPriority()

    def setRenderCallback(self, *args):
        r"""
        setRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * f, void *const userData=None)
        setRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * userData=None)
        """
        return _coin.SoRenderManager_setRenderCallback(self, *args)

    def addPreRenderCallback(self, *args):
        r"""
        addPreRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        addPreRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_addPreRenderCallback(self, *args)

    def removePreRenderCallback(self, *args):
        r"""
        removePreRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        removePreRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_removePreRenderCallback(self, *args)

    def addPostRenderCallback(self, *args):
        r"""
        addPostRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        addPostRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_addPostRenderCallback(self, *args)

    def removePostRenderCallback(self, *args):
        r"""
        removePostRenderCallback(SoRenderManager self, SoRenderManagerRenderCB * cb, void * data)
        removePostRenderCallback(SoRenderManager self, PyObject * pyfunc, PyObject * data)
        """
        return _coin.SoRenderManager_removePostRenderCallback(self, *args)

# Register SoRenderManager in _coin:
_coin.SoRenderManager_swigregister(SoRenderManager)
class ScXMLObject(object):
    r"""Proxy of C++ ScXMLObject class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLObject_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(ScXMLObject self) -> SoType"""
        return _coin.ScXMLObject_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.ScXMLObject_initClass()
    __swig_destroy__ = _coin.delete_ScXMLObject

    def isOfType(self, type):
        r"""isOfType(ScXMLObject self, SoType type) -> SbBool"""
        return _coin.ScXMLObject_isOfType(self, type)

    def setXMLAttribute(self, attribute, value):
        r"""setXMLAttribute(ScXMLObject self, char const * attribute, char const * value)"""
        return _coin.ScXMLObject_setXMLAttribute(self, attribute, value)

    def getXMLAttribute(self, attribute):
        r"""getXMLAttribute(ScXMLObject self, char const * attribute) -> char const *"""
        return _coin.ScXMLObject_getXMLAttribute(self, attribute)

    def handleXMLAttributes(self):
        r"""handleXMLAttributes(ScXMLObject self) -> SbBool"""
        return _coin.ScXMLObject_handleXMLAttributes(self)

    def setContainer(self, container):
        r"""setContainer(ScXMLObject self, ScXMLObject container)"""
        return _coin.ScXMLObject_setContainer(self, container)

    def getContainer(self):
        r"""getContainer(ScXMLObject self) -> ScXMLObject"""
        return _coin.ScXMLObject_getContainer(self)

    def isContainedIn(self, object):
        r"""isContainedIn(ScXMLObject self, ScXMLObject object) -> SbBool"""
        return _coin.ScXMLObject_isContainedIn(self, object)

# Register ScXMLObject in _coin:
_coin.ScXMLObject_swigregister(ScXMLObject)
class ScXMLEvent(ScXMLObject):
    r"""Proxy of C++ ScXMLEvent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLEvent_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(ScXMLEvent self) -> SoType"""
        return _coin.ScXMLEvent_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.ScXMLEvent_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.ScXMLEvent_initClass()

    def __init__(self):
        r"""__init__(ScXMLEvent self) -> ScXMLEvent"""
        _coin.ScXMLEvent_swiginit(self, _coin.new_ScXMLEvent())
    __swig_destroy__ = _coin.delete_ScXMLEvent

    def setIdentifier(self, identifier):
        r"""setIdentifier(ScXMLEvent self, SbName identifier)"""
        return _coin.ScXMLEvent_setIdentifier(self, identifier)

    def getIdentifier(self):
        r"""getIdentifier(ScXMLEvent self) -> SbName"""
        return _coin.ScXMLEvent_getIdentifier(self)

# Register ScXMLEvent in _coin:
_coin.ScXMLEvent_swigregister(ScXMLEvent)
SCXML_DEFAULT_NS = _coin.SCXML_DEFAULT_NS

SCXML_COIN_NS = _coin.SCXML_COIN_NS

class ScXML(object):
    r"""Proxy of C++ ScXML class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _coin.ScXML_initClasses()

    @staticmethod
    def readFile(filename):
        r"""readFile(char const * filename) -> ScXMLStateMachine"""
        return _coin.ScXML_readFile(filename)

    @staticmethod
    def readBuffer(bufferdata):
        r"""readBuffer(char const * bufferdata) -> ScXMLStateMachine"""
        return _coin.ScXML_readBuffer(bufferdata)

    def __init__(self):
        r"""__init__(ScXML self) -> ScXML"""
        _coin.ScXML_swiginit(self, _coin.new_ScXML())
    __swig_destroy__ = _coin.delete_ScXML

# Register ScXML in _coin:
_coin.ScXML_swigregister(ScXML)
class ScXMLInvoke(ScXMLObject):
    r"""Proxy of C++ ScXMLInvoke class."""

    thisown = property(lambda x: 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

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLInvoke_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(ScXMLInvoke self) -> SoType"""
        return _coin.ScXMLInvoke_getTypeId(self)

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.ScXMLInvoke_initClass()
    __swig_destroy__ = _coin.delete_ScXMLInvoke

    def setTargetTypeAttribute(self, id):
        r"""setTargetTypeAttribute(ScXMLInvoke self, char const * id)"""
        return _coin.ScXMLInvoke_setTargetTypeAttribute(self, id)

    def getTargetTypeAttribute(self):
        r"""getTargetTypeAttribute(ScXMLInvoke self) -> char const *"""
        return _coin.ScXMLInvoke_getTargetTypeAttribute(self)

    def setSrcAttribute(self, id):
        r"""setSrcAttribute(ScXMLInvoke self, char const * id)"""
        return _coin.ScXMLInvoke_setSrcAttribute(self, id)

    def getSrcAttribute(self):
        r"""getSrcAttribute(ScXMLInvoke self) -> char const *"""
        return _coin.ScXMLInvoke_getSrcAttribute(self)

    def setSrcExprAttribute(self, id):
        r"""setSrcExprAttribute(ScXMLInvoke self, char const * id)"""
        return _coin.ScXMLInvoke_setSrcExprAttribute(self, id)

    def getSrcExprAttribute(self):
        r"""getSrcExprAttribute(ScXMLInvoke self) -> char const *"""
        return _coin.ScXMLInvoke_getSrcExprAttribute(self)

    def handleXMLAttributes(self):
        r"""handleXMLAttributes(ScXMLInvoke self) -> SbBool"""
        return _coin.ScXMLInvoke_handleXMLAttributes(self)

    def invoke(self, statemachine):
        r"""invoke(ScXMLInvoke self, ScXMLStateMachine statemachine)"""
        return _coin.ScXMLInvoke_invoke(self, statemachine)

# Register ScXMLInvoke in _coin:
_coin.ScXMLInvoke_swigregister(ScXMLInvoke)
class ScXMLStateMachine(ScXMLObject):
    r"""Proxy of C++ ScXMLStateMachine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.ScXMLStateMachine_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(ScXMLStateMachine self) -> SoType"""
        return _coin.ScXMLStateMachine_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.ScXMLStateMachine_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.ScXMLStateMachine_initClass()

    def __init__(self):
        r"""__init__(ScXMLStateMachine self) -> ScXMLStateMachine"""
        _coin.ScXMLStateMachine_swiginit(self, _coin.new_ScXMLStateMachine())
    __swig_destroy__ = _coin.delete_ScXMLStateMachine

    def setName(self, name):
        r"""setName(ScXMLStateMachine self, SbName name)"""
        return _coin.ScXMLStateMachine_setName(self, name)

    def getName(self):
        r"""getName(ScXMLStateMachine self) -> SbName"""
        return _coin.ScXMLStateMachine_getName(self)

    def setDescription(self, document):
        r"""setDescription(ScXMLStateMachine self, ScXMLDocument * document)"""
        return _coin.ScXMLStateMachine_setDescription(self, document)

    def getDescription(self):
        r"""getDescription(ScXMLStateMachine self) -> ScXMLDocument const *"""
        return _coin.ScXMLStateMachine_getDescription(self)

    def initialize(self):
        r"""initialize(ScXMLStateMachine self)"""
        return _coin.ScXMLStateMachine_initialize(self)

    def queueEvent(self, *args):
        r"""
        queueEvent(ScXMLStateMachine self, ScXMLEvent event, SbBool dealloc=0)
        queueEvent(ScXMLStateMachine self, SbName eventid)
        """
        return _coin.ScXMLStateMachine_queueEvent(self, *args)

    def processEventQueue(self):
        r"""processEventQueue(ScXMLStateMachine self) -> SbBool"""
        return _coin.ScXMLStateMachine_processEventQueue(self)

    def isActive(self):
        r"""isActive(ScXMLStateMachine self) -> SbBool"""
        return _coin.ScXMLStateMachine_isActive(self)

    def isFinished(self):
        r"""isFinished(ScXMLStateMachine self) -> SbBool"""
        return _coin.ScXMLStateMachine_isFinished(self)

    def getCurrentEvent(self):
        r"""getCurrentEvent(ScXMLStateMachine self) -> ScXMLEvent"""
        return _coin.ScXMLStateMachine_getCurrentEvent(self)

    def getNumActiveStates(self):
        r"""getNumActiveStates(ScXMLStateMachine self) -> int"""
        return _coin.ScXMLStateMachine_getNumActiveStates(self)

    def getActiveState(self, idx):
        r"""getActiveState(ScXMLStateMachine self, int idx) -> ScXMLObject"""
        return _coin.ScXMLStateMachine_getActiveState(self, idx)

    def getState(self, identifier):
        r"""getState(ScXMLStateMachine self, char const * identifier) -> ScXMLObject"""
        return _coin.ScXMLStateMachine_getState(self, identifier)

    def addDeleteCallback(self, *args):
        r"""
        addDeleteCallback(ScXMLStateMachine self, ScXMLStateMachineDeleteCB * callback, void * userdata)
        addDeleteCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_addDeleteCallback(self, *args)

    def removeDeleteCallback(self, *args):
        r"""
        removeDeleteCallback(ScXMLStateMachine self, ScXMLStateMachineDeleteCB * callback, void * userdata)
        removeDeleteCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_removeDeleteCallback(self, *args)

    def addStateChangeCallback(self, *args):
        r"""
        addStateChangeCallback(ScXMLStateMachine self, ScXMLStateChangeCB * callback, void * userdata)
        addStateChangeCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_addStateChangeCallback(self, *args)

    def removeStateChangeCallback(self, *args):
        r"""
        removeStateChangeCallback(ScXMLStateMachine self, ScXMLStateChangeCB * callback, void * userdata)
        removeStateChangeCallback(ScXMLStateMachine self, PyObject * pyfunc, PyObject * userdata)
        """
        return _coin.ScXMLStateMachine_removeStateChangeCallback(self, *args)

# Register ScXMLStateMachine in _coin:
_coin.ScXMLStateMachine_swigregister(ScXMLStateMachine)
class SoScXMLEvent(ScXMLEvent):
    r"""Proxy of C++ SoScXMLEvent class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLEvent_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoScXMLEvent self) -> SoType"""
        return _coin.SoScXMLEvent_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoScXMLEvent_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoScXMLEvent_initClass()

    def __init__(self):
        r"""__init__(SoScXMLEvent self) -> SoScXMLEvent"""
        _coin.SoScXMLEvent_swiginit(self, _coin.new_SoScXMLEvent())
    __swig_destroy__ = _coin.delete_SoScXMLEvent

    def setSoEvent(self, soevent):
        r"""setSoEvent(SoScXMLEvent self, SoEvent soevent)"""
        return _coin.SoScXMLEvent_setSoEvent(self, soevent)

    def getSoEvent(self):
        r"""getSoEvent(SoScXMLEvent self) -> SoEvent"""
        return _coin.SoScXMLEvent_getSoEvent(self)

    def setUpIdentifier(self):
        r"""setUpIdentifier(SoScXMLEvent self)"""
        return _coin.SoScXMLEvent_setUpIdentifier(self)

# Register SoScXMLEvent in _coin:
_coin.SoScXMLEvent_swigregister(SoScXMLEvent)
class SoScXMLStateMachine(ScXMLStateMachine):
    r"""Proxy of C++ SoScXMLStateMachine class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _coin.SoScXMLStateMachine_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoScXMLStateMachine self) -> SoType"""
        return _coin.SoScXMLStateMachine_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _coin.SoScXMLStateMachine_createInstance()

    @staticmethod
    def initClass():
        r"""initClass()"""
        return _coin.SoScXMLStateMachine_initClass()

    def __init__(self):
        r"""__init__(SoScXMLStateMachine self) -> SoScXMLStateMachine"""
        _coin.SoScXMLStateMachine_swiginit(self, _coin.new_SoScXMLStateMachine())
    __swig_destroy__ = _coin.delete_SoScXMLStateMachine

    def setSceneGraphRoot(self, root):
        r"""setSceneGraphRoot(SoScXMLStateMachine self, SoNode root)"""
        return _coin.SoScXMLStateMachine_setSceneGraphRoot(self, root)

    def getSceneGraphRoot(self):
        r"""getSceneGraphRoot(SoScXMLStateMachine self) -> SoNode"""
        return _coin.SoScXMLStateMachine_getSceneGraphRoot(self)

    def setActiveCamera(self, camera):
        r"""setActiveCamera(SoScXMLStateMachine self, SoCamera camera)"""
        return _coin.SoScXMLStateMachine_setActiveCamera(self, camera)

    def getActiveCamera(self):
        r"""getActiveCamera(SoScXMLStateMachine self) -> SoCamera"""
        return _coin.SoScXMLStateMachine_getActiveCamera(self)

    def setViewportRegion(self, vp):
        r"""setViewportRegion(SoScXMLStateMachine self, SbViewportRegion vp)"""
        return _coin.SoScXMLStateMachine_setViewportRegion(self, vp)

    def getViewportRegion(self):
        r"""getViewportRegion(SoScXMLStateMachine self) -> SbViewportRegion"""
        return _coin.SoScXMLStateMachine_getViewportRegion(self)

    def preGLRender(self):
        r"""preGLRender(SoScXMLStateMachine self)"""
        return _coin.SoScXMLStateMachine_preGLRender(self)

    def postGLRender(self):
        r"""postGLRender(SoScXMLStateMachine self)"""
        return _coin.SoScXMLStateMachine_postGLRender(self)

    def processSoEvent(self, event):
        r"""processSoEvent(SoScXMLStateMachine self, SoEvent event) -> SbBool"""
        return _coin.SoScXMLStateMachine_processSoEvent(self, event)

# Register SoScXMLStateMachine in _coin:
_coin.SoScXMLStateMachine_swigregister(SoScXMLStateMachine)

for x in list(locals()):
  value = locals()[x]
  try:
    if isinstance(value, type) and issubclass(value, SoFieldContainer):
      for name in list(value.__dict__):
        val = value.__dict__[name]
        if isinstance(val, property):
          delattr(value, name)
  except NameError:
# value == SoSearchAction_duringSearchAll ???
    pass


