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

"""
The soqt module is a wrapper for the SoQt library. The module will try
to import the shiboken module which is used for PySide. If found the involved
wrapped Qt structures are converted to ones suitable for PySide,
otherwise it will fall back to regular SWIG structures.
"""

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _soqt
else:
    import _soqt

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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _soqt.charp_swiginit(self, _soqt.new_charp())
    __swig_destroy__ = _soqt.delete_charp

    def assign(self, value):
        return _soqt.charp_assign(self, value)

    def value(self):
        return _soqt.charp_value(self)

    def cast(self):
        return _soqt.charp_cast(self)

    @staticmethod
    def frompointer(t):
        return _soqt.charp_frompointer(t)

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

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

    def __init__(self):
        _soqt.intp_swiginit(self, _soqt.new_intp())
    __swig_destroy__ = _soqt.delete_intp

    def assign(self, value):
        return _soqt.intp_assign(self, value)

    def value(self):
        return _soqt.intp_value(self)

    def cast(self):
        return _soqt.intp_cast(self)

    @staticmethod
    def frompointer(t):
        return _soqt.intp_frompointer(t)

# Register intp in _soqt:
_soqt.intp_swigregister(intp)
class longp(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _soqt.longp_swiginit(self, _soqt.new_longp())
    __swig_destroy__ = _soqt.delete_longp

    def assign(self, value):
        return _soqt.longp_assign(self, value)

    def value(self):
        return _soqt.longp_value(self)

    def cast(self):
        return _soqt.longp_cast(self)

    @staticmethod
    def frompointer(t):
        return _soqt.longp_frompointer(t)

# Register longp in _soqt:
_soqt.longp_swigregister(longp)
class floatp(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _soqt.floatp_swiginit(self, _soqt.new_floatp())
    __swig_destroy__ = _soqt.delete_floatp

    def assign(self, value):
        return _soqt.floatp_assign(self, value)

    def value(self):
        return _soqt.floatp_value(self)

    def cast(self):
        return _soqt.floatp_cast(self)

    @staticmethod
    def frompointer(t):
        return _soqt.floatp_frompointer(t)

# Register floatp in _soqt:
_soqt.floatp_swigregister(floatp)
class doublep(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _soqt.doublep_swiginit(self, _soqt.new_doublep())
    __swig_destroy__ = _soqt.delete_doublep

    def assign(self, value):
        return _soqt.doublep_assign(self, value)

    def value(self):
        return _soqt.doublep_value(self)

    def cast(self):
        return _soqt.doublep_cast(self)

    @staticmethod
    def frompointer(t):
        return _soqt.doublep_frompointer(t)

# Register doublep in _soqt:
_soqt.doublep_swigregister(doublep)
FALSE = _soqt.FALSE
TRUE = _soqt.TRUE
HAVE_INTTYPES_H = _soqt.HAVE_INTTYPES_H
HAVE_STDINT_H = _soqt.HAVE_STDINT_H
HAVE_SYS_TYPES_H = _soqt.HAVE_SYS_TYPES_H
HAVE_STDDEF_H = _soqt.HAVE_STDDEF_H
HAVE_INT8_T = _soqt.HAVE_INT8_T
HAVE_UINT8_T = _soqt.HAVE_UINT8_T
HAVE_INT16_T = _soqt.HAVE_INT16_T
HAVE_UINT16_T = _soqt.HAVE_UINT16_T
HAVE_INT32_T = _soqt.HAVE_INT32_T
HAVE_UINT32_T = _soqt.HAVE_UINT32_T
HAVE_INT64_T = _soqt.HAVE_INT64_T
HAVE_UINT64_T = _soqt.HAVE_UINT64_T
HAVE_INTPTR_T = _soqt.HAVE_INTPTR_T
HAVE_UINTPTR_T = _soqt.HAVE_UINTPTR_T
M_E = _soqt.M_E
M_LOG2E = _soqt.M_LOG2E
M_LOG10E = _soqt.M_LOG10E
M_LN2 = _soqt.M_LN2
M_LN10 = _soqt.M_LN10
M_PI = _soqt.M_PI
M_TWOPI = _soqt.M_TWOPI
M_PI_2 = _soqt.M_PI_2
M_PI_4 = _soqt.M_PI_4
M_3PI_4 = _soqt.M_3PI_4
M_SQRTPI = _soqt.M_SQRTPI
M_1_PI = _soqt.M_1_PI
M_2_PI = _soqt.M_2_PI
M_2_SQRTPI = _soqt.M_2_SQRTPI
M_SQRT2 = _soqt.M_SQRT2
M_SQRT1_2 = _soqt.M_SQRT1_2
M_LN2LO = _soqt.M_LN2LO
M_LN2HI = _soqt.M_LN2HI
M_SQRT3 = _soqt.M_SQRT3
M_IVLN10 = _soqt.M_IVLN10
M_LOG2_E = _soqt.M_LOG2_E
M_INVLN2 = _soqt.M_INVLN2
COIN_MAJOR_VERSION = _soqt.COIN_MAJOR_VERSION
COIN_MINOR_VERSION = _soqt.COIN_MINOR_VERSION
COIN_MICRO_VERSION = _soqt.COIN_MICRO_VERSION
COIN_VERSION = _soqt.COIN_VERSION
HAVE_HASH_QUOTING = _soqt.HAVE_HASH_QUOTING
SUN_CC_4_0_SOTYPE_INIT_BUG = _soqt.SUN_CC_4_0_SOTYPE_INIT_BUG
class SbDict(object):
    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):
        _soqt.SbDict_swiginit(self, _soqt.new_SbDict(*args))
    __swig_destroy__ = _soqt.delete_SbDict

    def applyToAll(self, *args):
        return _soqt.SbDict_applyToAll(self, *args)

    def clear(self):
        return _soqt.SbDict_clear(self)

    def enter(self, key, value):
        return _soqt.SbDict_enter(self, key, value)

    def find(self, key, value):
        return _soqt.SbDict_find(self, key, value)

    def makePList(self, keys, values):
        return _soqt.SbDict_makePList(self, keys, values)

    def remove(self, key):
        return _soqt.SbDict_remove(self, key)

    def setHashingFunction(self, func):
        return _soqt.SbDict_setHashingFunction(self, func)

# Register SbDict in _soqt:
_soqt.SbDict_swigregister(SbDict)
class SoType(object):
    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):
        return _soqt.SoType_fromName(name)

    def getName(self):
        return _soqt.SoType_getName(self)

    def getParent(self):
        return _soqt.SoType_getParent(self)

    def isDerivedFrom(self, type):
        return _soqt.SoType_isDerivedFrom(self, type)

    @staticmethod
    def getAllDerivedFrom(type, list):
        return _soqt.SoType_getAllDerivedFrom(type, list)

    def canCreateInstance(self):
        return _soqt.SoType_canCreateInstance(self)

    def getData(self):
        return _soqt.SoType_getData(self)

    def getKey(self):
        return _soqt.SoType_getKey(self)

    def __eq__(self, type):
        return _soqt.SoType___eq__(self, type)

    def __ne__(self, type):
        return _soqt.SoType___ne__(self, type)

    def __lt__(self, type):
        return _soqt.SoType___lt__(self, type)

    def __le__(self, type):
        return _soqt.SoType___le__(self, type)

    def __ge__(self, type):
        return _soqt.SoType___ge__(self, type)

    def __gt__(self, type):
        return _soqt.SoType___gt__(self, type)

    @staticmethod
    def removeType(name):
        return _soqt.SoType_removeType(name)

    @staticmethod
    def init():
        return _soqt.SoType_init()

    @staticmethod
    def fromKey(key):
        return _soqt.SoType_fromKey(key)

    @staticmethod
    def badType():
        return _soqt.SoType_badType()

    def isBad(self):
        return _soqt.SoType_isBad(self)

    def makeInternal(self):
        return _soqt.SoType_makeInternal(self)

    def isInternal(self):
        return _soqt.SoType_isInternal(self)

    @staticmethod
    def getNumTypes():
        return _soqt.SoType_getNumTypes()

    def getInstantiationMethod(self):
        return _soqt.SoType_getInstantiationMethod(self)

    def createInstance(self):
        return _soqt.SoType_createInstance(self)

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

# Register SoType in _soqt:
_soqt.SoType_swigregister(SoType)
class SbPList(object):
    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):
        _soqt.SbPList_swiginit(self, _soqt.new_SbPList(*args))
    __swig_destroy__ = _soqt.delete_SbPList

    def copy(self, l):
        return _soqt.SbPList_copy(self, l)

    def fit(self):
        return _soqt.SbPList_fit(self)

    def append(self, item):
        return _soqt.SbPList_append(self, item)

    def find(self, item):
        return _soqt.SbPList_find(self, item)

    def insert(self, item, insertbefore):
        return _soqt.SbPList_insert(self, item, insertbefore)

    def removeItem(self, item):
        return _soqt.SbPList_removeItem(self, item)

    def remove(self, index):
        return _soqt.SbPList_remove(self, index)

    def removeFast(self, index):
        return _soqt.SbPList_removeFast(self, index)

    def getLength(self):
        return _soqt.SbPList_getLength(self)

    def truncate(self, length, fit=0):
        return _soqt.SbPList_truncate(self, length, fit)

    def getArrayPtr(self, start=0):
        return _soqt.SbPList_getArrayPtr(self, start)

    def __eq__(self, l):
        return _soqt.SbPList___eq__(self, l)

    def __ne__(self, l):
        return _soqt.SbPList___ne__(self, l)

    def get(self, index):
        return _soqt.SbPList_get(self, index)

    def set(self, index, item):
        return _soqt.SbPList_set(self, index, item)

    def __getitem__(self, i):
        return _soqt.SbPList___getitem__(self, i)

    def __setitem__(self, i, val):
        return _soqt.SbPList___setitem__(self, i, val)

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


# Register SbPList in _soqt:
_soqt.SbPList_swigregister(SbPList)
class SbIntList(SbPList):
    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):
        _soqt.SbIntList_swiginit(self, _soqt.new_SbIntList(*args))

    def append(self, item):
        return _soqt.SbIntList_append(self, item)

    def find(self, item):
        return _soqt.SbIntList_find(self, item)

    def insert(self, item, addbefore):
        return _soqt.SbIntList_insert(self, item, addbefore)

    def __setitem__(self, i, value):
        return _soqt.SbIntList___setitem__(self, i, value)

    def __getitem__(self, i):
        return _soqt.SbIntList___getitem__(self, i)

    def get(self, i):
        return _soqt.SbIntList_get(self, i)
    __swig_destroy__ = _soqt.delete_SbIntList

# Register SbIntList in _soqt:
_soqt.SbIntList_swigregister(SbIntList)
class SbString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        _soqt.SbString_swiginit(self, _soqt.new_SbString(*args))
    __swig_destroy__ = _soqt.delete_SbString

    @staticmethod
    def hash(*args):
        return _soqt.SbString_hash(*args)

    def getLength(self):
        return _soqt.SbString_getLength(self)

    def makeEmpty(self, freeold=1):
        return _soqt.SbString_makeEmpty(self, freeold)

    def getString(self):
        return _soqt.SbString_getString(self)

    def getSubString(self, startidx, endidx=-1):
        return _soqt.SbString_getSubString(self, startidx, endidx)

    def deleteSubString(self, startidx, endidx=-1):
        return _soqt.SbString_deleteSubString(self, startidx, endidx)

    def addIntString(self, value):
        return _soqt.SbString_addIntString(self, value)

    def __iadd__(self, *args):
        return _soqt.SbString___iadd__(self, *args)

    def compareSubString(self, text, offset=0):
        return _soqt.SbString_compareSubString(self, text, offset)

    def sprintf(self, formatstr):
        return _soqt.SbString_sprintf(self, formatstr)

    def apply(self, func):
        return _soqt.SbString_apply(self, func)

    def find(self, s):
        return _soqt.SbString_find(self, s)

    def findAll(self, s, found):
        return _soqt.SbString_findAll(self, s, found)

    def lower(self):
        return _soqt.SbString_lower(self)

    def upper(self):
        return _soqt.SbString_upper(self)

    def _print(self, fp):
        return _soqt.SbString__print(self, fp)

    def __eq__(self, *args):
        return _soqt.SbString___eq__(self, *args)

    def __nq__(self, *args):
        return _soqt.SbString___nq__(self, *args)

    def __getitem__(self, i):
        return _soqt.SbString___getitem__(self, i)

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


    def __repr__(self):
        return _soqt.SbString___repr__(self)

# Register SbString in _soqt:
_soqt.SbString_swigregister(SbString)
class SbName(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        _soqt.SbName_swiginit(self, _soqt.new_SbName(*args))
    __swig_destroy__ = _soqt.delete_SbName

    def getString(self):
        return _soqt.SbName_getString(self)

    def getLength(self):
        return _soqt.SbName_getLength(self)

    @staticmethod
    def isIdentStartChar(c):
        return _soqt.SbName_isIdentStartChar(c)

    @staticmethod
    def isIdentChar(c):
        return _soqt.SbName_isIdentChar(c)

    @staticmethod
    def isBaseNameStartChar(c):
        return _soqt.SbName_isBaseNameStartChar(c)

    @staticmethod
    def isBaseNameChar(c):
        return _soqt.SbName_isBaseNameChar(c)

    @staticmethod
    def empty():
        return _soqt.SbName_empty()

    def __eq__(self, *args):
        return _soqt.SbName___eq__(self, *args)

    def __nq__(self, *args):
        return _soqt.SbName___nq__(self, *args)

    def __getitem__(self, i):
        return _soqt.SbName___getitem__(self, i)

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


    def __repr__(self):
        return _soqt.SbName___repr__(self)

# Register SbName in _soqt:
_soqt.SbName_swigregister(SbName)
class SoError(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _soqt.SoError_swiginit(self, _soqt.new_SoError())
    __swig_destroy__ = _soqt.delete_SoError

    @staticmethod
    def setHandlerCallback(func, data):
        return _soqt.SoError_setHandlerCallback(func, data)

    @staticmethod
    def getHandlerCallback():
        return _soqt.SoError_getHandlerCallback()

    @staticmethod
    def getHandlerData():
        return _soqt.SoError_getHandlerData()

    def getDebugString(self):
        return _soqt.SoError_getDebugString(self)

    @staticmethod
    def getClassTypeId():
        return _soqt.SoError_getClassTypeId()

    def getTypeId(self):
        return _soqt.SoError_getTypeId(self)

    def isOfType(self, type):
        return _soqt.SoError_isOfType(self, type)

    @staticmethod
    def post(*args):
        return _soqt.SoError_post(*args)

    @staticmethod
    def getString(*args):
        return _soqt.SoError_getString(*args)

    @staticmethod
    def initClass():
        return _soqt.SoError_initClass()

    @staticmethod
    def initClasses():
        return _soqt.SoError_initClasses()

# Register SoError in _soqt:
_soqt.SoError_swigregister(SoError)
class SoDebugError(SoError):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ERROR = _soqt.SoDebugError_ERROR
    WARNING = _soqt.SoDebugError_WARNING
    INFO = _soqt.SoDebugError_INFO

    @staticmethod
    def setHandlerCallback(function, data):
        return _soqt.SoDebugError_setHandlerCallback(function, data)

    @staticmethod
    def getHandlerCallback():
        return _soqt.SoDebugError_getHandlerCallback()

    @staticmethod
    def getHandlerData():
        return _soqt.SoDebugError_getHandlerData()

    @staticmethod
    def getClassTypeId():
        return _soqt.SoDebugError_getClassTypeId()

    def getTypeId(self):
        return _soqt.SoDebugError_getTypeId(self)

    def getSeverity(self):
        return _soqt.SoDebugError_getSeverity(self)

    @staticmethod
    def post(*args):
        return _soqt.SoDebugError_post(*args)

    @staticmethod
    def postWarning(*args):
        return _soqt.SoDebugError_postWarning(*args)

    @staticmethod
    def postInfo(*args):
        return _soqt.SoDebugError_postInfo(*args)

    @staticmethod
    def initClass():
        return _soqt.SoDebugError_initClass()

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

# Register SoDebugError in _soqt:
_soqt.SoDebugError_swigregister(SoDebugError)
class SbVec2s(object):
    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):
        _soqt.SbVec2s_swiginit(self, _soqt.new_SbVec2s(*args))

    def setValue(self, *args):
        return _soqt.SbVec2s_setValue(self, *args)

    def getValue(self):
        return _soqt.SbVec2s_getValue(self)

    def dot(self, v):
        return _soqt.SbVec2s_dot(self, v)

    def negate(self):
        return _soqt.SbVec2s_negate(self)

    def __imul__(self, *args):
        return _soqt.SbVec2s___imul__(self, *args)

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



    def __iadd__(self, v):
        return _soqt.SbVec2s___iadd__(self, v)

    def __isub__(self, v):
        return _soqt.SbVec2s___isub__(self, v)

    def __neg__(self):
        return _soqt.SbVec2s___neg__(self)

    def toString(self):
        return _soqt.SbVec2s_toString(self)

    def fromString(self, str):
        return _soqt.SbVec2s_fromString(self, str)

    def output(self, fp):
        return _soqt.SbVec2s_output(self, fp)

    def __add__(self, u):
        return _soqt.SbVec2s___add__(self, u)

    def __sub__(self, u):
        return _soqt.SbVec2s___sub__(self, u)

    def __mul__(self, d):
        return _soqt.SbVec2s___mul__(self, d)

    def __rmul__(self, d):
        return _soqt.SbVec2s___rmul__(self, d)

    def __div__(self, d):
        return _soqt.SbVec2s___div__(self, d)

    def __truediv__(self, d):
        return _soqt.SbVec2s___truediv__(self, d)

    def __eq__(self, u):
        return _soqt.SbVec2s___eq__(self, u)

    def __nq__(self, u):
        return _soqt.SbVec2s___nq__(self, u)

    def __getitem__(self, i):
        return _soqt.SbVec2s___getitem__(self, i)

    def __setitem__(self, i, value):
        return _soqt.SbVec2s___setitem__(self, i, value)

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

    def __len__(self):
          return 2

    __swig_destroy__ = _soqt.delete_SbVec2s

# Register SbVec2s in _soqt:
_soqt.SbVec2s_swigregister(SbVec2s)
class SbVec2f(object):
    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):
        _soqt.SbVec2f_swiginit(self, _soqt.new_SbVec2f(*args))

    def setValue(self, *args):
        return _soqt.SbVec2f_setValue(self, *args)

    def getValue(self):
        return _soqt.SbVec2f_getValue(self)

    def dot(self, v):
        return _soqt.SbVec2f_dot(self, v)

    def equals(self, v, tolerance):
        return _soqt.SbVec2f_equals(self, v, tolerance)

    def length(self):
        return _soqt.SbVec2f_length(self)

    def sqrLength(self):
        return _soqt.SbVec2f_sqrLength(self)

    def negate(self):
        return _soqt.SbVec2f_negate(self)

    def normalize(self):
        return _soqt.SbVec2f_normalize(self)

    def __imul__(self, d):
        return _soqt.SbVec2f___imul__(self, d)

    def __itruediv__(self, *args):
        return _soqt.SbVec2f___itruediv__(self, *args)
    __idiv__ = __itruediv__



    def __iadd__(self, v):
        return _soqt.SbVec2f___iadd__(self, v)

    def __isub__(self, v):
        return _soqt.SbVec2f___isub__(self, v)

    def __neg__(self):
        return _soqt.SbVec2f___neg__(self)

    def toString(self):
        return _soqt.SbVec2f_toString(self)

    def fromString(self, str):
        return _soqt.SbVec2f_fromString(self, str)

    def output(self, fp):
        return _soqt.SbVec2f_output(self, fp)

    def __add__(self, u):
        return _soqt.SbVec2f___add__(self, u)

    def __sub__(self, u):
        return _soqt.SbVec2f___sub__(self, u)

    def __mul__(self, d):
        return _soqt.SbVec2f___mul__(self, d)

    def __rmul__(self, d):
        return _soqt.SbVec2f___rmul__(self, d)

    def __div__(self, d):
        return _soqt.SbVec2f___div__(self, d)

    def __truediv__(self, d):
        return _soqt.SbVec2f___truediv__(self, d)

    def __eq__(self, u):
        return _soqt.SbVec2f___eq__(self, u)

    def __nq__(self, u):
        return _soqt.SbVec2f___nq__(self, u)

    def __getitem__(self, i):
        return _soqt.SbVec2f___getitem__(self, i)

    def __setitem__(self, i, value):
        return _soqt.SbVec2f___setitem__(self, i, value)

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

    def __len__(self):
          return 2

    __swig_destroy__ = _soqt.delete_SbVec2f

# Register SbVec2f in _soqt:
_soqt.SbVec2f_swigregister(SbVec2f)
class SbTime(object):
    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):
        _soqt.SbTime_swiginit(self, _soqt.new_SbTime(*args))

    @staticmethod
    def getTimeOfDay():
        return _soqt.SbTime_getTimeOfDay()

    def setToTimeOfDay(self):
        return _soqt.SbTime_setToTimeOfDay(self)

    @staticmethod
    def zero():
        return _soqt.SbTime_zero()

    @staticmethod
    def max():
        return _soqt.SbTime_max()

    @staticmethod
    def maxTime():
        return _soqt.SbTime_maxTime()

    @staticmethod
    def sleep(msec):
        return _soqt.SbTime_sleep(msec)

    def setValue(self, *args):
        return _soqt.SbTime_setValue(self, *args)

    def setMsecValue(self, msec):
        return _soqt.SbTime_setMsecValue(self, msec)

    def getValue(self, *args):
        return _soqt.SbTime_getValue(self, *args)

    def getMsecValue(self):
        return _soqt.SbTime_getMsecValue(self)

    def format(self, *args):
        return _soqt.SbTime_format(self, *args)

    def formatDate(self, fmt=None):
        return _soqt.SbTime_formatDate(self, fmt)

    def parsedate(self, date):
        return _soqt.SbTime_parsedate(self, date)

    def __iadd__(self, tm):
        return _soqt.SbTime___iadd__(self, tm)

    def __isub__(self, tm):
        return _soqt.SbTime___isub__(self, tm)

    def __neg__(self):
        return _soqt.SbTime___neg__(self)

    def __imul__(self, s):
        return _soqt.SbTime___imul__(self, s)

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



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



    def __mod__(self, tm):
        return _soqt.SbTime___mod__(self, tm)

    def __eq__(self, tm):
        return _soqt.SbTime___eq__(self, tm)

    def __ne__(self, tm):
        return _soqt.SbTime___ne__(self, tm)

    def __lt__(self, tm):
        return _soqt.SbTime___lt__(self, tm)

    def __gt__(self, tm):
        return _soqt.SbTime___gt__(self, tm)

    def __le__(self, tm):
        return _soqt.SbTime___le__(self, tm)

    def __ge__(self, tm):
        return _soqt.SbTime___ge__(self, tm)

    def output(self, fp):
        return _soqt.SbTime_output(self, fp)

    def __add__(self, u):
        return _soqt.SbTime___add__(self, u)

    def __sub__(self, u):
        return _soqt.SbTime___sub__(self, u)

    def __mul__(self, d):
        return _soqt.SbTime___mul__(self, d)

    def __rmul__(self, d):
        return _soqt.SbTime___rmul__(self, d)

    def __div__(self, d):
        return _soqt.SbTime___div__(self, d)
    __swig_destroy__ = _soqt.delete_SbTime

# Register SbTime in _soqt:
_soqt.SbTime_swigregister(SbTime)
class SoEvent(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getClassTypeId():
        return _soqt.SoEvent_getClassTypeId()

    def getTypeId(self):
        return _soqt.SoEvent_getTypeId(self)

    @staticmethod
    def initClass():
        return _soqt.SoEvent_initClass()

    def __init__(self):
        _soqt.SoEvent_swiginit(self, _soqt.new_SoEvent())
    __swig_destroy__ = _soqt.delete_SoEvent

    def isOfType(self, type):
        return _soqt.SoEvent_isOfType(self, type)

    def setTime(self, t):
        return _soqt.SoEvent_setTime(self, t)

    def getTime(self):
        return _soqt.SoEvent_getTime(self)

    def setPosition(self, p):
        return _soqt.SoEvent_setPosition(self, p)

    def getPosition(self, *args):
        return _soqt.SoEvent_getPosition(self, *args)

    def getNormalizedPosition(self, vpRgn):
        return _soqt.SoEvent_getNormalizedPosition(self, vpRgn)

    def setShiftDown(self, isDown):
        return _soqt.SoEvent_setShiftDown(self, isDown)

    def wasShiftDown(self):
        return _soqt.SoEvent_wasShiftDown(self)

    def setCtrlDown(self, isDown):
        return _soqt.SoEvent_setCtrlDown(self, isDown)

    def wasCtrlDown(self):
        return _soqt.SoEvent_wasCtrlDown(self)

    def setAltDown(self, isDown):
        return _soqt.SoEvent_setAltDown(self, isDown)

    def wasAltDown(self):
        return _soqt.SoEvent_wasAltDown(self)

# Register SoEvent in _soqt:
_soqt.SoEvent_swigregister(SoEvent)
class SoNotRec(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CONTAINER = _soqt.SoNotRec_CONTAINER
    PARENT = _soqt.SoNotRec_PARENT
    SENSOR = _soqt.SoNotRec_SENSOR
    FIELD = _soqt.SoNotRec_FIELD
    ENGINE = _soqt.SoNotRec_ENGINE
    UNSPECIFIED = _soqt.SoNotRec_UNSPECIFIED
    FIELD_UPDATE = _soqt.SoNotRec_FIELD_UPDATE
    GROUP_ADDCHILD = _soqt.SoNotRec_GROUP_ADDCHILD
    GROUP_INSERTCHILD = _soqt.SoNotRec_GROUP_INSERTCHILD
    GROUP_REPLACECHILD = _soqt.SoNotRec_GROUP_REPLACECHILD
    GROUP_REMOVECHILD = _soqt.SoNotRec_GROUP_REMOVECHILD
    GROUP_REMOVEALLCHILDREN = _soqt.SoNotRec_GROUP_REMOVEALLCHILDREN

    def __init__(self, notifbase):
        _soqt.SoNotRec_swiginit(self, _soqt.new_SoNotRec(notifbase))

    def setType(self, type):
        return _soqt.SoNotRec_setType(self, type)

    def getBase(self):
        return _soqt.SoNotRec_getBase(self)

    def getType(self):
        return _soqt.SoNotRec_getType(self)

    def getPrevious(self):
        return _soqt.SoNotRec_getPrevious(self)

    def setPrevious(self, prev):
        return _soqt.SoNotRec_setPrevious(self, prev)

    def output(self, file):
        return _soqt.SoNotRec_output(self, file)

    def getOperationType(self):
        return _soqt.SoNotRec_getOperationType(self)

    def getIndex(self):
        return _soqt.SoNotRec_getIndex(self)

    def getFieldNumIndices(self):
        return _soqt.SoNotRec_getFieldNumIndices(self)

    def getGroupChild(self):
        return _soqt.SoNotRec_getGroupChild(self)

    def getGroupPrevChild(self):
        return _soqt.SoNotRec_getGroupPrevChild(self)

    def setOperationType(self, opType):
        return _soqt.SoNotRec_setOperationType(self, opType)

    def setIndex(self, idx):
        return _soqt.SoNotRec_setIndex(self, idx)

    def setFieldNumIndices(self, fldnumind):
        return _soqt.SoNotRec_setFieldNumIndices(self, fldnumind)

    def setGroupChild(self, gc):
        return _soqt.SoNotRec_setGroupChild(self, gc)

    def setGroupPrevChild(self, pc):
        return _soqt.SoNotRec_setGroupPrevChild(self, pc)
    __swig_destroy__ = _soqt.delete_SoNotRec

# Register SoNotRec in _soqt:
_soqt.SoNotRec_swigregister(SoNotRec)
class SoNotList(object):
    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):
        _soqt.SoNotList_swiginit(self, _soqt.new_SoNotList(*args))

    def append(self, *args):
        return _soqt.SoNotList_append(self, *args)

    def setLastType(self, type):
        return _soqt.SoNotList_setLastType(self, type)

    def getFirstRec(self):
        return _soqt.SoNotList_getFirstRec(self)

    def getLastRec(self):
        return _soqt.SoNotList_getLastRec(self)

    def getFirstRecAtNode(self):
        return _soqt.SoNotList_getFirstRecAtNode(self)

    def getLastField(self):
        return _soqt.SoNotList_getLastField(self)

    def getLastEngineOutput(self):
        return _soqt.SoNotList_getLastEngineOutput(self)

    def getTimeStamp(self):
        return _soqt.SoNotList_getTimeStamp(self)

    def output(self, *args):
        return _soqt.SoNotList_output(self, *args)
    __swig_destroy__ = _soqt.delete_SoNotList

# Register SoNotList in _soqt:
_soqt.SoNotList_swigregister(SoNotList)
class SoField(object):
    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__ = _soqt.delete_SoField

    @staticmethod
    def initClass():
        return _soqt.SoField_initClass()

    @staticmethod
    def initClasses():
        return _soqt.SoField_initClasses()

    @staticmethod
    def cleanupClass():
        return _soqt.SoField_cleanupClass()

    def setIgnored(self, ignore):
        return _soqt.SoField_setIgnored(self, ignore)

    def isIgnored(self):
        return _soqt.SoField_isIgnored(self)

    def setDefault(self, defaultVal):
        return _soqt.SoField_setDefault(self, defaultVal)

    def isDefault(self):
        return _soqt.SoField_isDefault(self)

    def getTypeId(self):
        return _soqt.SoField_getTypeId(self)

    @staticmethod
    def getClassTypeId():
        return _soqt.SoField_getClassTypeId()

    def isOfType(self, type):
        return _soqt.SoField_isOfType(self, type)

    def enableConnection(self, flag):
        return _soqt.SoField_enableConnection(self, flag)

    def isConnectionEnabled(self):
        return _soqt.SoField_isConnectionEnabled(self)

    def isConnectedFromEngine(self):
        return _soqt.SoField_isConnectedFromEngine(self)

    def getConnectedEngine(self, master):
        return _soqt.SoField_getConnectedEngine(self, master)

    def connectFrom(self, *args):
        return _soqt.SoField_connectFrom(self, *args)

    def appendConnection(self, *args):
        return _soqt.SoField_appendConnection(self, *args)

    def isConnectedFromField(self):
        return _soqt.SoField_isConnectedFromField(self)

    def getConnectedField(self, master):
        return _soqt.SoField_getConnectedField(self, master)

    def getNumConnections(self):
        return _soqt.SoField_getNumConnections(self)

    def getForwardConnections(self, slavelist):
        return _soqt.SoField_getForwardConnections(self, slavelist)

    def getConnections(self, masterlist):
        return _soqt.SoField_getConnections(self, masterlist)

    def disconnect(self, *args):
        return _soqt.SoField_disconnect(self, *args)

    def isConnected(self):
        return _soqt.SoField_isConnected(self)

    def setContainer(self, cont):
        return _soqt.SoField_setContainer(self, cont)

    def getContainer(self):
        return _soqt.SoField_getContainer(self)

    def set(self, valuestring):
        return _soqt.SoField_set(self, valuestring)

    def shouldWrite(self):
        return _soqt.SoField_shouldWrite(self)

    def touch(self):
        return _soqt.SoField_touch(self)

    def startNotify(self):
        return _soqt.SoField_startNotify(self)

    def notify(self, nlist):
        return _soqt.SoField_notify(self, nlist)

    def enableNotify(self, on):
        return _soqt.SoField_enableNotify(self, on)

    def isNotifyEnabled(self):
        return _soqt.SoField_isNotifyEnabled(self)

    def addAuditor(self, f, type):
        return _soqt.SoField_addAuditor(self, f, type)

    def removeAuditor(self, f, type):
        return _soqt.SoField_removeAuditor(self, f, type)

    def __eq__(self, f):
        return _soqt.SoField___eq__(self, f)

    def __ne__(self, f):
        return _soqt.SoField___ne__(self, f)

    def connectionStatusChanged(self, numconnections):
        return _soqt.SoField_connectionStatusChanged(self, numconnections)

    def isReadOnly(self):
        return _soqt.SoField_isReadOnly(self)

    def isSame(self, f):
        return _soqt.SoField_isSame(self, f)

    def copyFrom(self, f):
        return _soqt.SoField_copyFrom(self, f)

    def fixCopy(self, copyconnections):
        return _soqt.SoField_fixCopy(self, copyconnections)

    def referencesCopy(self):
        return _soqt.SoField_referencesCopy(self)

    def copyConnection(self, fromfield):
        return _soqt.SoField_copyConnection(self, fromfield)

    def read(self, input, name):
        return _soqt.SoField_read(self, input, name)

    def write(self, out, name):
        return _soqt.SoField_write(self, out, name)

    def countWriteRefs(self, out):
        return _soqt.SoField_countWriteRefs(self, out)
    NORMAL_FIELD = _soqt.SoField_NORMAL_FIELD
    EVENTIN_FIELD = _soqt.SoField_EVENTIN_FIELD
    EVENTOUT_FIELD = _soqt.SoField_EVENTOUT_FIELD
    EXPOSED_FIELD = _soqt.SoField_EXPOSED_FIELD

    def setFieldType(self, type):
        return _soqt.SoField_setFieldType(self, type)

    def getFieldType(self):
        return _soqt.SoField_getFieldType(self)

    def getDirty(self):
        return _soqt.SoField_getDirty(self)

    def setDirty(self, dirty):
        return _soqt.SoField_setDirty(self, dirty)

    def evaluate(self):
        return _soqt.SoField_evaluate(self)

    def get(self):
        return _soqt.SoField_get(self)

# Register SoField in _soqt:
_soqt.SoField_swigregister(SoField)
class SoSField(SoField):
    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__ = _soqt.delete_SoSField

    @staticmethod
    def initClass():
        return _soqt.SoSField_initClass()

    @staticmethod
    def getClassTypeId():
        return _soqt.SoSField_getClassTypeId()

    @staticmethod
    def atexit_cleanup():
        return _soqt.SoSField_atexit_cleanup()

# Register SoSField in _soqt:
_soqt.SoSField_swigregister(SoSField)
class SoMField(SoField):
    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__ = _soqt.delete_SoMField

    @staticmethod
    def getClassTypeId():
        return _soqt.SoMField_getClassTypeId()

    @staticmethod
    def atexit_cleanup():
        return _soqt.SoMField_atexit_cleanup()

    def getNum(self):
        return _soqt.SoMField_getNum(self)

    def setNum(self, num):
        return _soqt.SoMField_setNum(self, num)

    def deleteValues(self, start, num=-1):
        return _soqt.SoMField_deleteValues(self, start, num)

    def insertSpace(self, start, num):
        return _soqt.SoMField_insertSpace(self, start, num)

    def set1(self, index, valuestring):
        return _soqt.SoMField_set1(self, index, valuestring)

    @staticmethod
    def initClass():
        return _soqt.SoMField_initClass()

    def enableDeleteValues(self):
        return _soqt.SoMField_enableDeleteValues(self)

    def isDeleteValuesEnabled(self):
        return _soqt.SoMField_isDeleteValuesEnabled(self)

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


    def __len__(self):
        return _soqt.SoMField___len__(self)

    def get1(self, index):
        return _soqt.SoMField_get1(self, index)

    @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 SoMField in _soqt:
_soqt.SoMField_swigregister(SoMField)
import pivy.coin
class QEvent(object):
    r"""Proxy of C++ QEvent 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__ = _soqt.delete_QEvent

# Register QEvent in _soqt:
_soqt.QEvent_swigregister(QEvent)
class QWidget(object):
    r"""Proxy of C++ QWidget 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__ = _soqt.delete_QWidget

# Register QWidget in _soqt:
_soqt.QWidget_swigregister(QWidget)
SOQT_MAJOR_VERSION = _soqt.SOQT_MAJOR_VERSION

SOQT_MINOR_VERSION = _soqt.SOQT_MINOR_VERSION

SOQT_MICRO_VERSION = _soqt.SOQT_MICRO_VERSION

SOQT_VERSION = _soqt.SOQT_VERSION

GUI_TOOLKIT_VERSION = _soqt.GUI_TOOLKIT_VERSION

class SoQtObject(object):
    r"""Proxy of C++ SoQtObject 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 _soqt.SoQtObject_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtObject_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtObject self) -> SoType"""
        return _soqt.SoQtObject_getTypeId(self)

    def isOfType(self, type):
        r"""isOfType(SoQtObject self, SoType type) -> SbBool"""
        return _soqt.SoQtObject_isOfType(self, type)

    @staticmethod
    def init():
        r"""init()"""
        return _soqt.SoQtObject_init()
    __swig_destroy__ = _soqt.delete_SoQtObject

# Register SoQtObject in _soqt:
_soqt.SoQtObject_swigregister(SoQtObject)
SOQT_SUN_CC_4_0_SOTYPE_INIT_BUG = _soqt.SOQT_SUN_CC_4_0_SOTYPE_INIT_BUG

class SoQtDevice(SoQtObject):
    r"""Proxy of C++ SoQtDevice 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 _soqt.SoQtDevice_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtDevice_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtDevice self) -> SoType"""
        return _soqt.SoQtDevice_getTypeId(self)
    __swig_destroy__ = _soqt.delete_SoQtDevice

    def enable(self, w, handler, closure):
        r"""enable(SoQtDevice self, QWidget w, SoQtEventHandler * handler, void * closure)"""
        return _soqt.SoQtDevice_enable(self, w, handler, closure)

    def disable(self, w, handler, closure):
        r"""disable(SoQtDevice self, QWidget w, SoQtEventHandler * handler, void * closure)"""
        return _soqt.SoQtDevice_disable(self, w, handler, closure)

    def translateEvent(self, event):
        r"""translateEvent(SoQtDevice self, QEvent event) -> SoEvent"""
        return _soqt.SoQtDevice_translateEvent(self, event)

    def setWindowSize(self, size):
        r"""setWindowSize(SoQtDevice self, SbVec2s size)"""
        return _soqt.SoQtDevice_setWindowSize(self, size)

    def getWindowSize(self):
        r"""getWindowSize(SoQtDevice self) -> SbVec2s"""
        return _soqt.SoQtDevice_getWindowSize(self)

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _soqt.SoQtDevice_initClasses()

# Register SoQtDevice in _soqt:
_soqt.SoQtDevice_swigregister(SoQtDevice)
class SoQtKeyboard(SoQtDevice):
    r"""Proxy of C++ SoQtKeyboard 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 _soqt.SoQtKeyboard_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtKeyboard_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtKeyboard self) -> SoType"""
        return _soqt.SoQtKeyboard_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _soqt.SoQtKeyboard_createInstance()
    KEY_PRESS = _soqt.SoQtKeyboard_KEY_PRESS
    
    KEY_RELEASE = _soqt.SoQtKeyboard_KEY_RELEASE
    
    ALL_EVENTS = _soqt.SoQtKeyboard_ALL_EVENTS
    

    def __init__(self, *args):
        r"""__init__(SoQtKeyboard self, int eventmask=ALL_EVENTS) -> SoQtKeyboard"""
        _soqt.SoQtKeyboard_swiginit(self, _soqt.new_SoQtKeyboard(*args))
    __swig_destroy__ = _soqt.delete_SoQtKeyboard

    def enable(self, widget, handler, closure):
        r"""enable(SoQtKeyboard self, QWidget widget, SoQtEventHandler * handler, void * closure)"""
        return _soqt.SoQtKeyboard_enable(self, widget, handler, closure)

    def disable(self, widget, handler, closure):
        r"""disable(SoQtKeyboard self, QWidget widget, SoQtEventHandler * handler, void * closure)"""
        return _soqt.SoQtKeyboard_disable(self, widget, handler, closure)

    def translateEvent(self, event):
        r"""translateEvent(SoQtKeyboard self, QEvent event) -> SoEvent"""
        return _soqt.SoQtKeyboard_translateEvent(self, event)

# Register SoQtKeyboard in _soqt:
_soqt.SoQtKeyboard_swigregister(SoQtKeyboard)
class SoQtMouse(SoQtDevice):
    r"""Proxy of C++ SoQtMouse 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 _soqt.SoQtMouse_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtMouse_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtMouse self) -> SoType"""
        return _soqt.SoQtMouse_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _soqt.SoQtMouse_createInstance()
    BUTTON_PRESS = _soqt.SoQtMouse_BUTTON_PRESS
    
    BUTTON_RELEASE = _soqt.SoQtMouse_BUTTON_RELEASE
    
    POINTER_MOTION = _soqt.SoQtMouse_POINTER_MOTION
    
    BUTTON_MOTION = _soqt.SoQtMouse_BUTTON_MOTION
    
    ALL_EVENTS = _soqt.SoQtMouse_ALL_EVENTS
    

    def __init__(self, *args):
        r"""__init__(SoQtMouse self, int eventmask=ALL_EVENTS) -> SoQtMouse"""
        _soqt.SoQtMouse_swiginit(self, _soqt.new_SoQtMouse(*args))
    __swig_destroy__ = _soqt.delete_SoQtMouse

    def enable(self, widget, handler, closure):
        r"""enable(SoQtMouse self, QWidget widget, SoQtEventHandler * handler, void * closure)"""
        return _soqt.SoQtMouse_enable(self, widget, handler, closure)

    def disable(self, widget, handler, closure):
        r"""disable(SoQtMouse self, QWidget widget, SoQtEventHandler * handler, void * closure)"""
        return _soqt.SoQtMouse_disable(self, widget, handler, closure)

    def translateEvent(self, event):
        r"""translateEvent(SoQtMouse self, QEvent event) -> SoEvent"""
        return _soqt.SoQtMouse_translateEvent(self, event)

# Register SoQtMouse in _soqt:
_soqt.SoQtMouse_swigregister(SoQtMouse)
class SoQt(object):
    r"""Proxy of C++ SoQt 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 init(*args):
        r"""
        init(char const * appname, char const * classname="SoQt") -> QWidget
        init(int & argc, char ** argv, char const * appname, char const * classname="SoQt") -> QWidget
        init(QWidget toplevelwidget)
        """
        return _soqt.SoQt_init(*args)

    @staticmethod
    def exitMainLoop():
        r"""exitMainLoop()"""
        return _soqt.SoQt_exitMainLoop()

    @staticmethod
    def done():
        r"""done()"""
        return _soqt.SoQt_done()

    @staticmethod
    def getTopLevelWidget():
        r"""getTopLevelWidget() -> QWidget"""
        return _soqt.SoQt_getTopLevelWidget()

    @staticmethod
    def getShellWidget(w):
        r"""getShellWidget(QWidget w) -> QWidget"""
        return _soqt.SoQt_getShellWidget(w)

    @staticmethod
    def show(widget):
        r"""show(QWidget widget)"""
        return _soqt.SoQt_show(widget)

    @staticmethod
    def hide(widget):
        r"""hide(QWidget widget)"""
        return _soqt.SoQt_hide(widget)

    @staticmethod
    def setWidgetSize(widget, size):
        r"""setWidgetSize(QWidget widget, SbVec2s size)"""
        return _soqt.SoQt_setWidgetSize(widget, size)

    @staticmethod
    def getWidgetSize(widget):
        r"""getWidgetSize(QWidget widget) -> SbVec2s"""
        return _soqt.SoQt_getWidgetSize(widget)

    @staticmethod
    def createSimpleErrorDialog(widget, title, string1, string2=None):
        r"""createSimpleErrorDialog(QWidget widget, char const * title, char const * string1, char const * string2=None)"""
        return _soqt.SoQt_createSimpleErrorDialog(widget, title, string1, string2)

    @staticmethod
    def getVersionInfo(major=None, minor=None, micro=None):
        r"""getVersionInfo(int * major=None, int * minor=None, int * micro=None)"""
        return _soqt.SoQt_getVersionInfo(major, minor, micro)

    @staticmethod
    def getVersionString():
        r"""getVersionString() -> char const *"""
        return _soqt.SoQt_getVersionString()

    @staticmethod
    def getVersionToolkitString():
        r"""getVersionToolkitString() -> char const *"""
        return _soqt.SoQt_getVersionToolkitString()
    UNSPECIFIED_ERROR = _soqt.SoQt_UNSPECIFIED_ERROR
    
    NO_OPENGL_CANVAS = _soqt.SoQt_NO_OPENGL_CANVAS
    
    INTERNAL_ASSERT = _soqt.SoQt_INTERNAL_ASSERT
    

    @staticmethod
    def setFatalErrorHandler(cb, userdata):
        r"""setFatalErrorHandler(SoQt::FatalErrorCB * cb, void * userdata) -> SoQt::FatalErrorCB *"""
        return _soqt.SoQt_setFatalErrorHandler(cb, userdata)

    @staticmethod
    def isDebugLibrary():
        r"""isDebugLibrary() -> SbBool"""
        return _soqt.SoQt_isDebugLibrary()

    @staticmethod
    def isCompatible(major, minor):
        r"""isCompatible(unsigned int major, unsigned int minor) -> SbBool"""
        return _soqt.SoQt_isCompatible(major, minor)
    DLL = _soqt.SoQt_DLL
    
    LIB = _soqt.SoQt_LIB
    
    UNKNOWN = _soqt.SoQt_UNKNOWN
    

    @staticmethod
    def getABIType():
        r"""getABIType() -> SoQt::ABIType"""
        return _soqt.SoQt_getABIType()

    @staticmethod
    def lockGL():
        r"""lockGL()"""
        return _soqt.SoQt_lockGL()

    @staticmethod
    def unlockGL():
        r"""unlockGL()"""
        return _soqt.SoQt_unlockGL()

    @staticmethod
    def mainLoop():
        r"""mainLoop()"""
        return _soqt.SoQt_mainLoop()

# Register SoQt in _soqt:
_soqt.SoQt_swigregister(SoQt)
class SoQtComponent(SoQtObject):
    r"""Proxy of C++ SoQtComponent 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 initClass():
        r"""initClass()"""
        return _soqt.SoQtComponent_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtComponent_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtComponent self) -> SoType"""
        return _soqt.SoQtComponent_getTypeId(self)
    __swig_destroy__ = _soqt.delete_SoQtComponent

    def show(self):
        r"""show(SoQtComponent self)"""
        return _soqt.SoQtComponent_show(self)

    def hide(self):
        r"""hide(SoQtComponent self)"""
        return _soqt.SoQtComponent_hide(self)

    def setComponentCursor(self, cursor):
        r"""setComponentCursor(SoQtComponent self, SoQtCursor cursor)"""
        return _soqt.SoQtComponent_setComponentCursor(self, cursor)

    @staticmethod
    def setWidgetCursor(w, cursor):
        r"""setWidgetCursor(QWidget w, SoQtCursor cursor)"""
        return _soqt.SoQtComponent_setWidgetCursor(w, cursor)

    def isFullScreen(self):
        r"""isFullScreen(SoQtComponent self) -> SbBool"""
        return _soqt.SoQtComponent_isFullScreen(self)

    def setFullScreen(self, onoff):
        r"""setFullScreen(SoQtComponent self, SbBool const onoff) -> SbBool"""
        return _soqt.SoQtComponent_setFullScreen(self, onoff)

    def isVisible(self):
        r"""isVisible(SoQtComponent self) -> SbBool"""
        return _soqt.SoQtComponent_isVisible(self)

    def isTopLevelShell(self):
        r"""isTopLevelShell(SoQtComponent self) -> SbBool"""
        return _soqt.SoQtComponent_isTopLevelShell(self)

    def getWidget(self):
        r"""getWidget(SoQtComponent self) -> QWidget"""
        return _soqt.SoQtComponent_getWidget(self)

    def getBaseWidget(self):
        r"""getBaseWidget(SoQtComponent self) -> QWidget"""
        return _soqt.SoQtComponent_getBaseWidget(self)

    def getShellWidget(self):
        r"""getShellWidget(SoQtComponent self) -> QWidget"""
        return _soqt.SoQtComponent_getShellWidget(self)

    def getParentWidget(self):
        r"""getParentWidget(SoQtComponent self) -> QWidget"""
        return _soqt.SoQtComponent_getParentWidget(self)

    def setSize(self, size):
        r"""setSize(SoQtComponent self, SbVec2s size)"""
        return _soqt.SoQtComponent_setSize(self, size)

    def getSize(self):
        r"""getSize(SoQtComponent self) -> SbVec2s"""
        return _soqt.SoQtComponent_getSize(self)

    def setTitle(self, title):
        r"""setTitle(SoQtComponent self, char const *const title)"""
        return _soqt.SoQtComponent_setTitle(self, title)

    def getTitle(self):
        r"""getTitle(SoQtComponent self) -> char const *"""
        return _soqt.SoQtComponent_getTitle(self)

    def setIconTitle(self, title):
        r"""setIconTitle(SoQtComponent self, char const *const title)"""
        return _soqt.SoQtComponent_setIconTitle(self, title)

    def getIconTitle(self):
        r"""getIconTitle(SoQtComponent self) -> char const *"""
        return _soqt.SoQtComponent_getIconTitle(self)

    def getWidgetName(self):
        r"""getWidgetName(SoQtComponent self) -> char const *"""
        return _soqt.SoQtComponent_getWidgetName(self)

    def getClassName(self):
        r"""getClassName(SoQtComponent self) -> char const *"""
        return _soqt.SoQtComponent_getClassName(self)

    def setWindowCloseCallback(self, func, user=None):
        r"""setWindowCloseCallback(SoQtComponent self, SoQtComponentCB *const func, void *const user=None)"""
        return _soqt.SoQtComponent_setWindowCloseCallback(self, func, user)

    @staticmethod
    def getComponent(widget):
        r"""getComponent(QWidget widget) -> SoQtComponent"""
        return _soqt.SoQtComponent_getComponent(widget)

    @staticmethod
    def initClasses():
        r"""initClasses()"""
        return _soqt.SoQtComponent_initClasses()

# Register SoQtComponent in _soqt:
_soqt.SoQtComponent_swigregister(SoQtComponent)
SO_GL_RGB = _soqt.SO_GL_RGB

SO_GLX_RGB = _soqt.SO_GLX_RGB

SO_GL_DOUBLE = _soqt.SO_GL_DOUBLE

SO_GLX_DOUBLE = _soqt.SO_GLX_DOUBLE

SO_GL_ZBUFFER = _soqt.SO_GL_ZBUFFER

SO_GLX_ZBUFFER = _soqt.SO_GLX_ZBUFFER

SO_GL_OVERLAY = _soqt.SO_GL_OVERLAY

SO_GLX_OVERLAY = _soqt.SO_GLX_OVERLAY

SO_GL_STEREO = _soqt.SO_GL_STEREO

SO_GLX_STEREO = _soqt.SO_GLX_STEREO

class SoQtGLWidget(SoQtComponent):
    r"""Proxy of C++ SoQtGLWidget 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 _soqt.SoQtGLWidget_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtGLWidget_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtGLWidget self) -> SoType"""
        return _soqt.SoQtGLWidget_getTypeId(self)

    def setBorder(self, enable):
        r"""setBorder(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setBorder(self, enable)

    def isBorder(self):
        r"""isBorder(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_isBorder(self)

    def setDoubleBuffer(self, enable):
        r"""setDoubleBuffer(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setDoubleBuffer(self, enable)

    def isDoubleBuffer(self):
        r"""isDoubleBuffer(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_isDoubleBuffer(self)

    def setDrawToFrontBufferEnable(self, enable):
        r"""setDrawToFrontBufferEnable(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setDrawToFrontBufferEnable(self, enable)

    def isDrawToFrontBufferEnable(self):
        r"""isDrawToFrontBufferEnable(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_isDrawToFrontBufferEnable(self)

    def setQuadBufferStereo(self, enable):
        r"""setQuadBufferStereo(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setQuadBufferStereo(self, enable)

    def isQuadBufferStereo(self):
        r"""isQuadBufferStereo(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_isQuadBufferStereo(self)

    def setAccumulationBuffer(self, enable):
        r"""setAccumulationBuffer(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setAccumulationBuffer(self, enable)

    def getAccumulationBuffer(self):
        r"""getAccumulationBuffer(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_getAccumulationBuffer(self)

    def setStencilBuffer(self, enable):
        r"""setStencilBuffer(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setStencilBuffer(self, enable)

    def getStencilBuffer(self):
        r"""getStencilBuffer(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_getStencilBuffer(self)

    def setAlphaChannel(self, enable):
        r"""setAlphaChannel(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setAlphaChannel(self, enable)

    def getAlphaChannel(self):
        r"""getAlphaChannel(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_getAlphaChannel(self)

    def setOverlayRender(self, onoff):
        r"""setOverlayRender(SoQtGLWidget self, SbBool const onoff)"""
        return _soqt.SoQtGLWidget_setOverlayRender(self, onoff)

    def isOverlayRender(self):
        r"""isOverlayRender(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_isOverlayRender(self)

    def setSampleBuffers(self, numsamples):
        r"""setSampleBuffers(SoQtGLWidget self, int const numsamples)"""
        return _soqt.SoQtGLWidget_setSampleBuffers(self, numsamples)

    def getSampleBuffers(self):
        r"""getSampleBuffers(SoQtGLWidget self) -> int"""
        return _soqt.SoQtGLWidget_getSampleBuffers(self)

    def setStealFocus(self, enable):
        r"""setStealFocus(SoQtGLWidget self, SbBool enable)"""
        return _soqt.SoQtGLWidget_setStealFocus(self, enable)

    def isStealFocus(self):
        r"""isStealFocus(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_isStealFocus(self)

    def getGLWidget(self):
        r"""getGLWidget(SoQtGLWidget self) -> QWidget"""
        return _soqt.SoQtGLWidget_getGLWidget(self)

    def getNormalWidget(self):
        r"""getNormalWidget(SoQtGLWidget self) -> QWidget"""
        return _soqt.SoQtGLWidget_getNormalWidget(self)

    def getOverlayWidget(self):
        r"""getOverlayWidget(SoQtGLWidget self) -> QWidget"""
        return _soqt.SoQtGLWidget_getOverlayWidget(self)

    def hasOverlayGLArea(self):
        r"""hasOverlayGLArea(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_hasOverlayGLArea(self)

    def hasNormalGLArea(self):
        r"""hasNormalGLArea(SoQtGLWidget self) -> SbBool"""
        return _soqt.SoQtGLWidget_hasNormalGLArea(self)

    def getOverlayTransparentPixel(self):
        r"""getOverlayTransparentPixel(SoQtGLWidget self) -> unsigned long"""
        return _soqt.SoQtGLWidget_getOverlayTransparentPixel(self)

    def getPointSizeLimits(self, range, granularity):
        r"""getPointSizeLimits(SoQtGLWidget self, SbVec2f range, float & granularity)"""
        return _soqt.SoQtGLWidget_getPointSizeLimits(self, range, granularity)

    def getLineWidthLimits(self, range, granularity):
        r"""getLineWidthLimits(SoQtGLWidget self, SbVec2f range, float & granularity)"""
        return _soqt.SoQtGLWidget_getLineWidthLimits(self, range, granularity)

# Register SoQtGLWidget in _soqt:
_soqt.SoQtGLWidget_swigregister(SoQtGLWidget)
class SoQtRenderArea(SoQtGLWidget):
    r"""Proxy of C++ SoQtRenderArea 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 _soqt.SoQtRenderArea_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtRenderArea_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtRenderArea self) -> SoType"""
        return _soqt.SoQtRenderArea_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _soqt.SoQtRenderArea_createInstance()

    def __init__(self, parent=None, name=None, embed=1, mouseInput=1, keyboardInput=1):
        r"""__init__(SoQtRenderArea self, QWidget parent=None, char const * name=None, SbBool embed=1, SbBool mouseInput=1, SbBool keyboardInput=1) -> SoQtRenderArea"""
        _soqt.SoQtRenderArea_swiginit(self, _soqt.new_SoQtRenderArea(parent, name, embed, mouseInput, keyboardInput))
    __swig_destroy__ = _soqt.delete_SoQtRenderArea

    def setSceneGraph(self, scene):
        r"""setSceneGraph(SoQtRenderArea self, SoNode scene)"""
        return _soqt.SoQtRenderArea_setSceneGraph(self, scene)

    def getSceneGraph(self):
        r"""getSceneGraph(SoQtRenderArea self) -> SoNode"""
        return _soqt.SoQtRenderArea_getSceneGraph(self)

    def setOverlaySceneGraph(self, scene):
        r"""setOverlaySceneGraph(SoQtRenderArea self, SoNode scene)"""
        return _soqt.SoQtRenderArea_setOverlaySceneGraph(self, scene)

    def getOverlaySceneGraph(self):
        r"""getOverlaySceneGraph(SoQtRenderArea self) -> SoNode"""
        return _soqt.SoQtRenderArea_getOverlaySceneGraph(self)

    def setBackgroundColor(self, color):
        r"""setBackgroundColor(SoQtRenderArea self, SbColor color)"""
        return _soqt.SoQtRenderArea_setBackgroundColor(self, color)

    def getBackgroundColor(self):
        r"""getBackgroundColor(SoQtRenderArea self) -> SbColor"""
        return _soqt.SoQtRenderArea_getBackgroundColor(self)

    def setBackgroundIndex(self, idx):
        r"""setBackgroundIndex(SoQtRenderArea self, int idx)"""
        return _soqt.SoQtRenderArea_setBackgroundIndex(self, idx)

    def getBackgroundIndex(self):
        r"""getBackgroundIndex(SoQtRenderArea self) -> int"""
        return _soqt.SoQtRenderArea_getBackgroundIndex(self)

    def setOverlayBackgroundIndex(self, idx):
        r"""setOverlayBackgroundIndex(SoQtRenderArea self, int idx)"""
        return _soqt.SoQtRenderArea_setOverlayBackgroundIndex(self, idx)

    def getOverlayBackgroundIndex(self):
        r"""getOverlayBackgroundIndex(SoQtRenderArea self) -> int"""
        return _soqt.SoQtRenderArea_getOverlayBackgroundIndex(self)

    def setColorMap(self, start, num, colors):
        r"""setColorMap(SoQtRenderArea self, int start, int num, SbColor colors)"""
        return _soqt.SoQtRenderArea_setColorMap(self, start, num, colors)

    def setOverlayColorMap(self, start, num, colors):
        r"""setOverlayColorMap(SoQtRenderArea self, int start, int num, SbColor colors)"""
        return _soqt.SoQtRenderArea_setOverlayColorMap(self, start, num, colors)

    def setViewportRegion(self, newRegion):
        r"""setViewportRegion(SoQtRenderArea self, SbViewportRegion newRegion)"""
        return _soqt.SoQtRenderArea_setViewportRegion(self, newRegion)

    def getViewportRegion(self):
        r"""getViewportRegion(SoQtRenderArea self) -> SbViewportRegion"""
        return _soqt.SoQtRenderArea_getViewportRegion(self)

    def setTransparencyType(self, type):
        r"""setTransparencyType(SoQtRenderArea self, SoGLRenderAction::TransparencyType type)"""
        return _soqt.SoQtRenderArea_setTransparencyType(self, type)

    def getTransparencyType(self):
        r"""getTransparencyType(SoQtRenderArea self) -> SoGLRenderAction::TransparencyType"""
        return _soqt.SoQtRenderArea_getTransparencyType(self)

    def setAntialiasing(self, smoothing, numPasses):
        r"""setAntialiasing(SoQtRenderArea self, SbBool smoothing, int numPasses)"""
        return _soqt.SoQtRenderArea_setAntialiasing(self, smoothing, numPasses)

    def getAntialiasing(self, smoothing, numPasses):
        r"""getAntialiasing(SoQtRenderArea self, SbBool & smoothing, int & numPasses)"""
        return _soqt.SoQtRenderArea_getAntialiasing(self, smoothing, numPasses)

    def setClearBeforeRender(self, enable, zbEnable=1):
        r"""setClearBeforeRender(SoQtRenderArea self, SbBool enable, SbBool zbEnable=1)"""
        return _soqt.SoQtRenderArea_setClearBeforeRender(self, enable, zbEnable)

    def isClearBeforeRender(self):
        r"""isClearBeforeRender(SoQtRenderArea self) -> SbBool"""
        return _soqt.SoQtRenderArea_isClearBeforeRender(self)

    def isClearZBufferBeforeRender(self):
        r"""isClearZBufferBeforeRender(SoQtRenderArea self) -> SbBool"""
        return _soqt.SoQtRenderArea_isClearZBufferBeforeRender(self)

    def setClearBeforeOverlayRender(self, enable):
        r"""setClearBeforeOverlayRender(SoQtRenderArea self, SbBool enable)"""
        return _soqt.SoQtRenderArea_setClearBeforeOverlayRender(self, enable)

    def isClearBeforeOverlayRender(self):
        r"""isClearBeforeOverlayRender(SoQtRenderArea self) -> SbBool"""
        return _soqt.SoQtRenderArea_isClearBeforeOverlayRender(self)

    def setAutoRedraw(self, enable):
        r"""setAutoRedraw(SoQtRenderArea self, SbBool enable)"""
        return _soqt.SoQtRenderArea_setAutoRedraw(self, enable)

    def isAutoRedraw(self):
        r"""isAutoRedraw(SoQtRenderArea self) -> SbBool"""
        return _soqt.SoQtRenderArea_isAutoRedraw(self)

    def setRedrawPriority(self, priority):
        r"""setRedrawPriority(SoQtRenderArea self, uint32_t priority)"""
        return _soqt.SoQtRenderArea_setRedrawPriority(self, priority)

    def getRedrawPriority(self):
        r"""getRedrawPriority(SoQtRenderArea self) -> uint32_t"""
        return _soqt.SoQtRenderArea_getRedrawPriority(self)

    @staticmethod
    def getDefaultRedrawPriority():
        r"""getDefaultRedrawPriority() -> uint32_t"""
        return _soqt.SoQtRenderArea_getDefaultRedrawPriority()

    def render(self):
        r"""render(SoQtRenderArea self)"""
        return _soqt.SoQtRenderArea_render(self)

    def renderOverlay(self):
        r"""renderOverlay(SoQtRenderArea self)"""
        return _soqt.SoQtRenderArea_renderOverlay(self)

    def scheduleRedraw(self):
        r"""scheduleRedraw(SoQtRenderArea self)"""
        return _soqt.SoQtRenderArea_scheduleRedraw(self)

    def scheduleOverlayRedraw(self):
        r"""scheduleOverlayRedraw(SoQtRenderArea self)"""
        return _soqt.SoQtRenderArea_scheduleOverlayRedraw(self)

    def redrawOnSelectionChange(self, selection):
        r"""redrawOnSelectionChange(SoQtRenderArea self, SoSelection selection)"""
        return _soqt.SoQtRenderArea_redrawOnSelectionChange(self, selection)

    def redrawOverlayOnSelectionChange(self, selection):
        r"""redrawOverlayOnSelectionChange(SoQtRenderArea self, SoSelection selection)"""
        return _soqt.SoQtRenderArea_redrawOverlayOnSelectionChange(self, selection)

    def setSceneManager(self, manager):
        r"""setSceneManager(SoQtRenderArea self, SoSceneManager manager)"""
        return _soqt.SoQtRenderArea_setSceneManager(self, manager)

    def getSceneManager(self):
        r"""getSceneManager(SoQtRenderArea self) -> SoSceneManager"""
        return _soqt.SoQtRenderArea_getSceneManager(self)

    def setOverlaySceneManager(self, manager):
        r"""setOverlaySceneManager(SoQtRenderArea self, SoSceneManager manager)"""
        return _soqt.SoQtRenderArea_setOverlaySceneManager(self, manager)

    def getOverlaySceneManager(self):
        r"""getOverlaySceneManager(SoQtRenderArea self) -> SoSceneManager"""
        return _soqt.SoQtRenderArea_getOverlaySceneManager(self)

    def setGLRenderAction(self, action):
        r"""setGLRenderAction(SoQtRenderArea self, SoGLRenderAction action)"""
        return _soqt.SoQtRenderArea_setGLRenderAction(self, action)

    def getGLRenderAction(self):
        r"""getGLRenderAction(SoQtRenderArea self) -> SoGLRenderAction"""
        return _soqt.SoQtRenderArea_getGLRenderAction(self)

    def setOverlayGLRenderAction(self, action):
        r"""setOverlayGLRenderAction(SoQtRenderArea self, SoGLRenderAction action)"""
        return _soqt.SoQtRenderArea_setOverlayGLRenderAction(self, action)

    def getOverlayGLRenderAction(self):
        r"""getOverlayGLRenderAction(SoQtRenderArea self) -> SoGLRenderAction"""
        return _soqt.SoQtRenderArea_getOverlayGLRenderAction(self)

    def sendSoEvent(self, event):
        r"""sendSoEvent(SoQtRenderArea self, SoEvent event) -> SbBool"""
        return _soqt.SoQtRenderArea_sendSoEvent(self, event)

    def registerDevice(self, device):
        r"""registerDevice(SoQtRenderArea self, SoQtDevice device)"""
        return _soqt.SoQtRenderArea_registerDevice(self, device)

    def unregisterDevice(self, device):
        r"""unregisterDevice(SoQtRenderArea self, SoQtDevice device)"""
        return _soqt.SoQtRenderArea_unregisterDevice(self, device)

    def setEventCallback(self, *args):
        r"""
        setEventCallback(SoQtRenderArea self, SoQtRenderAreaEventCB * func, void * user=None)
        setEventCallback(SoQtRenderArea self, PyObject * pyfunc, PyObject * user=None)
        """
        return _soqt.SoQtRenderArea_setEventCallback(self, *args)

# Register SoQtRenderArea in _soqt:
_soqt.SoQtRenderArea_swigregister(SoQtRenderArea)
class SoQtViewer(SoQtRenderArea):
    r"""Proxy of C++ SoQtViewer 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 initClass():
        r"""initClass()"""
        return _soqt.SoQtViewer_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtViewer_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtViewer self) -> SoType"""
        return _soqt.SoQtViewer_getTypeId(self)
    BROWSER = _soqt.SoQtViewer_BROWSER
    
    EDITOR = _soqt.SoQtViewer_EDITOR
    
    VIEW_AS_IS = _soqt.SoQtViewer_VIEW_AS_IS
    
    VIEW_HIDDEN_LINE = _soqt.SoQtViewer_VIEW_HIDDEN_LINE
    
    VIEW_NO_TEXTURE = _soqt.SoQtViewer_VIEW_NO_TEXTURE
    
    VIEW_LOW_COMPLEXITY = _soqt.SoQtViewer_VIEW_LOW_COMPLEXITY
    
    VIEW_LINE = _soqt.SoQtViewer_VIEW_LINE
    
    VIEW_POINT = _soqt.SoQtViewer_VIEW_POINT
    
    VIEW_BBOX = _soqt.SoQtViewer_VIEW_BBOX
    
    VIEW_LOW_RES_LINE = _soqt.SoQtViewer_VIEW_LOW_RES_LINE
    
    VIEW_LOW_RES_POINT = _soqt.SoQtViewer_VIEW_LOW_RES_POINT
    
    VIEW_SAME_AS_STILL = _soqt.SoQtViewer_VIEW_SAME_AS_STILL
    
    VIEW_WIREFRAME_OVERLAY = _soqt.SoQtViewer_VIEW_WIREFRAME_OVERLAY
    
    STILL = _soqt.SoQtViewer_STILL
    
    INTERACTIVE = _soqt.SoQtViewer_INTERACTIVE
    
    BUFFER_SINGLE = _soqt.SoQtViewer_BUFFER_SINGLE
    
    BUFFER_DOUBLE = _soqt.SoQtViewer_BUFFER_DOUBLE
    
    BUFFER_INTERACTIVE = _soqt.SoQtViewer_BUFFER_INTERACTIVE
    
    VARIABLE_NEAR_PLANE = _soqt.SoQtViewer_VARIABLE_NEAR_PLANE
    
    CONSTANT_NEAR_PLANE = _soqt.SoQtViewer_CONSTANT_NEAR_PLANE
    

    def setCamera(self, camera):
        r"""setCamera(SoQtViewer self, SoCamera camera)"""
        return _soqt.SoQtViewer_setCamera(self, camera)

    def getCamera(self):
        r"""getCamera(SoQtViewer self) -> SoCamera"""
        return _soqt.SoQtViewer_getCamera(self)

    def setCameraType(self, type):
        r"""setCameraType(SoQtViewer self, SoType type)"""
        return _soqt.SoQtViewer_setCameraType(self, type)

    def getCameraType(self):
        r"""getCameraType(SoQtViewer self) -> SoType"""
        return _soqt.SoQtViewer_getCameraType(self)

    def toggleCameraType(self):
        r"""toggleCameraType(SoQtViewer self)"""
        return _soqt.SoQtViewer_toggleCameraType(self)

    def viewAll(self):
        r"""viewAll(SoQtViewer self)"""
        return _soqt.SoQtViewer_viewAll(self)

    def saveHomePosition(self):
        r"""saveHomePosition(SoQtViewer self)"""
        return _soqt.SoQtViewer_saveHomePosition(self)

    def resetToHomePosition(self):
        r"""resetToHomePosition(SoQtViewer self)"""
        return _soqt.SoQtViewer_resetToHomePosition(self)

    def setHeadlight(self, enable):
        r"""setHeadlight(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setHeadlight(self, enable)

    def isHeadlight(self):
        r"""isHeadlight(SoQtViewer self) -> SbBool"""
        return _soqt.SoQtViewer_isHeadlight(self)

    def getHeadlight(self):
        r"""getHeadlight(SoQtViewer self) -> SoDirectionalLight"""
        return _soqt.SoQtViewer_getHeadlight(self)

    def setDrawStyle(self, type, style):
        r"""setDrawStyle(SoQtViewer self, SoQtViewer::DrawType type, SoQtViewer::DrawStyle style)"""
        return _soqt.SoQtViewer_setDrawStyle(self, type, style)

    def getDrawStyle(self, type):
        r"""getDrawStyle(SoQtViewer self, SoQtViewer::DrawType const type) -> SoQtViewer::DrawStyle"""
        return _soqt.SoQtViewer_getDrawStyle(self, type)

    def setBufferingType(self, type):
        r"""setBufferingType(SoQtViewer self, SoQtViewer::BufferType type)"""
        return _soqt.SoQtViewer_setBufferingType(self, type)

    def getBufferingType(self):
        r"""getBufferingType(SoQtViewer self) -> SoQtViewer::BufferType"""
        return _soqt.SoQtViewer_getBufferingType(self)

    def setViewing(self, enable):
        r"""setViewing(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setViewing(self, enable)

    def isViewing(self):
        r"""isViewing(SoQtViewer self) -> SbBool"""
        return _soqt.SoQtViewer_isViewing(self)

    def setCursorEnabled(self, enable):
        r"""setCursorEnabled(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setCursorEnabled(self, enable)

    def isCursorEnabled(self):
        r"""isCursorEnabled(SoQtViewer self) -> SbBool"""
        return _soqt.SoQtViewer_isCursorEnabled(self)

    def setAutoClipping(self, enable):
        r"""setAutoClipping(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setAutoClipping(self, enable)

    def isAutoClipping(self):
        r"""isAutoClipping(SoQtViewer self) -> SbBool"""
        return _soqt.SoQtViewer_isAutoClipping(self)

    def setAutoClippingStrategy(self, strategy, value=0.6, cb=None, cbuserdata=None):
        r"""setAutoClippingStrategy(SoQtViewer self, SoQtViewer::AutoClippingStrategy const strategy, float const value=0.6, SoQtAutoClippingCB * cb=None, void * cbuserdata=None)"""
        return _soqt.SoQtViewer_setAutoClippingStrategy(self, strategy, value, cb, cbuserdata)

    def setStereoViewing(self, enable):
        r"""setStereoViewing(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setStereoViewing(self, enable)

    def isStereoViewing(self):
        r"""isStereoViewing(SoQtViewer self) -> SbBool"""
        return _soqt.SoQtViewer_isStereoViewing(self)

    def setStereoOffset(self, dist):
        r"""setStereoOffset(SoQtViewer self, float const dist)"""
        return _soqt.SoQtViewer_setStereoOffset(self, dist)

    def getStereoOffset(self):
        r"""getStereoOffset(SoQtViewer self) -> float"""
        return _soqt.SoQtViewer_getStereoOffset(self)
    STEREO_NONE = _soqt.SoQtViewer_STEREO_NONE
    
    STEREO_ANAGLYPH = _soqt.SoQtViewer_STEREO_ANAGLYPH
    
    STEREO_QUADBUFFER = _soqt.SoQtViewer_STEREO_QUADBUFFER
    
    STEREO_INTERLEAVED_ROWS = _soqt.SoQtViewer_STEREO_INTERLEAVED_ROWS
    
    STEREO_INTERLEAVED_COLUMNS = _soqt.SoQtViewer_STEREO_INTERLEAVED_COLUMNS
    

    def setStereoType(self, s):
        r"""setStereoType(SoQtViewer self, SoQtViewer::StereoType s) -> SbBool"""
        return _soqt.SoQtViewer_setStereoType(self, s)

    def getStereoType(self):
        r"""getStereoType(SoQtViewer self) -> SoQtViewer::StereoType"""
        return _soqt.SoQtViewer_getStereoType(self)

    def setAnaglyphStereoColorMasks(self, left, right):
        r"""setAnaglyphStereoColorMasks(SoQtViewer self, SbBool const [3] left, SbBool const [3] right)"""
        return _soqt.SoQtViewer_setAnaglyphStereoColorMasks(self, left, right)

    def getAnaglyphStereoColorMasks(self, left, right):
        r"""getAnaglyphStereoColorMasks(SoQtViewer self, SbBool [3] left, SbBool [3] right)"""
        return _soqt.SoQtViewer_getAnaglyphStereoColorMasks(self, left, right)

    def setDetailSeek(self, enable):
        r"""setDetailSeek(SoQtViewer self, SbBool const enable)"""
        return _soqt.SoQtViewer_setDetailSeek(self, enable)

    def isDetailSeek(self):
        r"""isDetailSeek(SoQtViewer self) -> SbBool"""
        return _soqt.SoQtViewer_isDetailSeek(self)

    def setSeekTime(self, seconds):
        r"""setSeekTime(SoQtViewer self, float const seconds)"""
        return _soqt.SoQtViewer_setSeekTime(self, seconds)

    def getSeekTime(self):
        r"""getSeekTime(SoQtViewer self) -> float"""
        return _soqt.SoQtViewer_getSeekTime(self)

    def addStartCallback(self, func, data=None):
        r"""addStartCallback(SoQtViewer self, SoQtViewerCB * func, void * data=None)"""
        return _soqt.SoQtViewer_addStartCallback(self, func, data)

    def addFinishCallback(self, func, data=None):
        r"""addFinishCallback(SoQtViewer self, SoQtViewerCB * func, void * data=None)"""
        return _soqt.SoQtViewer_addFinishCallback(self, func, data)

    def removeStartCallback(self, func, data=None):
        r"""removeStartCallback(SoQtViewer self, SoQtViewerCB * func, void * data=None)"""
        return _soqt.SoQtViewer_removeStartCallback(self, func, data)

    def removeFinishCallback(self, func, data=None):
        r"""removeFinishCallback(SoQtViewer self, SoQtViewerCB * func, void * data=None)"""
        return _soqt.SoQtViewer_removeFinishCallback(self, func, data)

    def setWireframeOverlayColor(self, color):
        r"""setWireframeOverlayColor(SoQtViewer self, SbColor color)"""
        return _soqt.SoQtViewer_setWireframeOverlayColor(self, color)

    def getWireframeOverlayColor(self):
        r"""getWireframeOverlayColor(SoQtViewer self) -> SbColor"""
        return _soqt.SoQtViewer_getWireframeOverlayColor(self)

    def setDoubleBuffer(self, enable):
        r"""setDoubleBuffer(SoQtViewer self, SbBool const enable)"""
        return _soqt.SoQtViewer_setDoubleBuffer(self, enable)

    def setSceneGraph(self, root):
        r"""setSceneGraph(SoQtViewer self, SoNode root)"""
        return _soqt.SoQtViewer_setSceneGraph(self, root)

    def getSceneGraph(self):
        r"""getSceneGraph(SoQtViewer self) -> SoNode"""
        return _soqt.SoQtViewer_getSceneGraph(self)

# Register SoQtViewer in _soqt:
_soqt.SoQtViewer_swigregister(SoQtViewer)
class SoQtFullViewer(SoQtViewer):
    r"""Proxy of C++ SoQtFullViewer 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 initClass():
        r"""initClass()"""
        return _soqt.SoQtFullViewer_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtFullViewer_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtFullViewer self) -> SoType"""
        return _soqt.SoQtFullViewer_getTypeId(self)
    BUILD_NONE = _soqt.SoQtFullViewer_BUILD_NONE
    
    BUILD_DECORATION = _soqt.SoQtFullViewer_BUILD_DECORATION
    
    BUILD_POPUP = _soqt.SoQtFullViewer_BUILD_POPUP
    
    BUILD_ALL = _soqt.SoQtFullViewer_BUILD_ALL
    

    def setDecoration(self, on):
        r"""setDecoration(SoQtFullViewer self, SbBool const on)"""
        return _soqt.SoQtFullViewer_setDecoration(self, on)

    def isDecoration(self):
        r"""isDecoration(SoQtFullViewer self) -> SbBool"""
        return _soqt.SoQtFullViewer_isDecoration(self)

    def setPopupMenuEnabled(self, on):
        r"""setPopupMenuEnabled(SoQtFullViewer self, SbBool const on)"""
        return _soqt.SoQtFullViewer_setPopupMenuEnabled(self, on)

    def isPopupMenuEnabled(self):
        r"""isPopupMenuEnabled(SoQtFullViewer self) -> SbBool"""
        return _soqt.SoQtFullViewer_isPopupMenuEnabled(self)

    def getAppPushButtonParent(self):
        r"""getAppPushButtonParent(SoQtFullViewer self) -> QWidget"""
        return _soqt.SoQtFullViewer_getAppPushButtonParent(self)

    def addAppPushButton(self, newButton):
        r"""addAppPushButton(SoQtFullViewer self, QWidget newButton)"""
        return _soqt.SoQtFullViewer_addAppPushButton(self, newButton)

    def insertAppPushButton(self, newButton, index):
        r"""insertAppPushButton(SoQtFullViewer self, QWidget newButton, int index)"""
        return _soqt.SoQtFullViewer_insertAppPushButton(self, newButton, index)

    def removeAppPushButton(self, oldButton):
        r"""removeAppPushButton(SoQtFullViewer self, QWidget oldButton)"""
        return _soqt.SoQtFullViewer_removeAppPushButton(self, oldButton)

    def findAppPushButton(self, oldButton):
        r"""findAppPushButton(SoQtFullViewer self, QWidget oldButton) -> int"""
        return _soqt.SoQtFullViewer_findAppPushButton(self, oldButton)

    def lengthAppPushButton(self):
        r"""lengthAppPushButton(SoQtFullViewer self) -> int"""
        return _soqt.SoQtFullViewer_lengthAppPushButton(self)

    def getRenderAreaWidget(self):
        r"""getRenderAreaWidget(SoQtFullViewer self) -> QWidget"""
        return _soqt.SoQtFullViewer_getRenderAreaWidget(self)

    def setViewing(self, on):
        r"""setViewing(SoQtFullViewer self, SbBool on)"""
        return _soqt.SoQtFullViewer_setViewing(self, on)

    def setComponentCursor(self, cursor):
        r"""setComponentCursor(SoQtFullViewer self, SoQtCursor cursor)"""
        return _soqt.SoQtFullViewer_setComponentCursor(self, cursor)

# Register SoQtFullViewer in _soqt:
_soqt.SoQtFullViewer_swigregister(SoQtFullViewer)
class SoQtPlaneViewer(SoQtFullViewer):
    r"""Proxy of C++ SoQtPlaneViewer 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 _soqt.SoQtPlaneViewer_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtPlaneViewer_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtPlaneViewer self) -> SoType"""
        return _soqt.SoQtPlaneViewer_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _soqt.SoQtPlaneViewer_createInstance()

    def __init__(self, *args):
        r"""__init__(SoQtPlaneViewer self, QWidget parent=None, char const *const name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag=BUILD_ALL, SoQtViewer::Type type=BROWSER) -> SoQtPlaneViewer"""
        _soqt.SoQtPlaneViewer_swiginit(self, _soqt.new_SoQtPlaneViewer(*args))
    __swig_destroy__ = _soqt.delete_SoQtPlaneViewer

    def setViewing(self, enable):
        r"""setViewing(SoQtPlaneViewer self, SbBool enable)"""
        return _soqt.SoQtPlaneViewer_setViewing(self, enable)

    def setCamera(self, camera):
        r"""setCamera(SoQtPlaneViewer self, SoCamera camera)"""
        return _soqt.SoQtPlaneViewer_setCamera(self, camera)

    def setCursorEnabled(self, enable):
        r"""setCursorEnabled(SoQtPlaneViewer self, SbBool enable)"""
        return _soqt.SoQtPlaneViewer_setCursorEnabled(self, enable)

# Register SoQtPlaneViewer in _soqt:
_soqt.SoQtPlaneViewer_swigregister(SoQtPlaneViewer)
class SoQtExaminerViewer(SoQtFullViewer):
    r"""Proxy of C++ SoQtExaminerViewer 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 _soqt.SoQtExaminerViewer_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtExaminerViewer_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtExaminerViewer self) -> SoType"""
        return _soqt.SoQtExaminerViewer_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _soqt.SoQtExaminerViewer_createInstance()

    def __init__(self, *args):
        r"""__init__(SoQtExaminerViewer self, QWidget parent=None, char const * name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag=BUILD_ALL, SoQtViewer::Type type=BROWSER) -> SoQtExaminerViewer"""
        _soqt.SoQtExaminerViewer_swiginit(self, _soqt.new_SoQtExaminerViewer(*args))
    __swig_destroy__ = _soqt.delete_SoQtExaminerViewer

    def setAnimationEnabled(self, enable):
        r"""setAnimationEnabled(SoQtExaminerViewer self, SbBool const enable)"""
        return _soqt.SoQtExaminerViewer_setAnimationEnabled(self, enable)

    def isAnimationEnabled(self):
        r"""isAnimationEnabled(SoQtExaminerViewer self) -> SbBool"""
        return _soqt.SoQtExaminerViewer_isAnimationEnabled(self)

    def stopAnimating(self):
        r"""stopAnimating(SoQtExaminerViewer self)"""
        return _soqt.SoQtExaminerViewer_stopAnimating(self)

    def isAnimating(self):
        r"""isAnimating(SoQtExaminerViewer self) -> SbBool"""
        return _soqt.SoQtExaminerViewer_isAnimating(self)

    def setFeedbackVisibility(self, enable):
        r"""setFeedbackVisibility(SoQtExaminerViewer self, SbBool const enable)"""
        return _soqt.SoQtExaminerViewer_setFeedbackVisibility(self, enable)

    def isFeedbackVisible(self):
        r"""isFeedbackVisible(SoQtExaminerViewer self) -> SbBool"""
        return _soqt.SoQtExaminerViewer_isFeedbackVisible(self)

    def setFeedbackSize(self, size):
        r"""setFeedbackSize(SoQtExaminerViewer self, int const size)"""
        return _soqt.SoQtExaminerViewer_setFeedbackSize(self, size)

    def getFeedbackSize(self):
        r"""getFeedbackSize(SoQtExaminerViewer self) -> int"""
        return _soqt.SoQtExaminerViewer_getFeedbackSize(self)

    def setViewing(self, enable):
        r"""setViewing(SoQtExaminerViewer self, SbBool enable)"""
        return _soqt.SoQtExaminerViewer_setViewing(self, enable)

    def setCamera(self, camera):
        r"""setCamera(SoQtExaminerViewer self, SoCamera camera)"""
        return _soqt.SoQtExaminerViewer_setCamera(self, camera)

    def setCursorEnabled(self, enable):
        r"""setCursorEnabled(SoQtExaminerViewer self, SbBool enable)"""
        return _soqt.SoQtExaminerViewer_setCursorEnabled(self, enable)

# Register SoQtExaminerViewer in _soqt:
_soqt.SoQtExaminerViewer_swigregister(SoQtExaminerViewer)
class SoQtConstrainedViewer(SoQtFullViewer):
    r"""Proxy of C++ SoQtConstrainedViewer 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 initClass():
        r"""initClass()"""
        return _soqt.SoQtConstrainedViewer_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtConstrainedViewer_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtConstrainedViewer self) -> SoType"""
        return _soqt.SoQtConstrainedViewer_getTypeId(self)

    def setUpDirection(self, dir):
        r"""setUpDirection(SoQtConstrainedViewer self, SbVec3f dir)"""
        return _soqt.SoQtConstrainedViewer_setUpDirection(self, dir)

    def getUpDirection(self):
        r"""getUpDirection(SoQtConstrainedViewer self) -> SbVec3f"""
        return _soqt.SoQtConstrainedViewer_getUpDirection(self)

    def setCamera(self, newcam):
        r"""setCamera(SoQtConstrainedViewer self, SoCamera newcam)"""
        return _soqt.SoQtConstrainedViewer_setCamera(self, newcam)

    def saveHomePosition(self):
        r"""saveHomePosition(SoQtConstrainedViewer self)"""
        return _soqt.SoQtConstrainedViewer_saveHomePosition(self)

    def resetToHomePosition(self):
        r"""resetToHomePosition(SoQtConstrainedViewer self)"""
        return _soqt.SoQtConstrainedViewer_resetToHomePosition(self)

# Register SoQtConstrainedViewer in _soqt:
_soqt.SoQtConstrainedViewer_swigregister(SoQtConstrainedViewer)
class SoQtFlyViewer(SoQtConstrainedViewer):
    r"""Proxy of C++ SoQtFlyViewer 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 _soqt.SoQtFlyViewer_initClass()

    @staticmethod
    def getClassTypeId():
        r"""getClassTypeId() -> SoType"""
        return _soqt.SoQtFlyViewer_getClassTypeId()

    def getTypeId(self):
        r"""getTypeId(SoQtFlyViewer self) -> SoType"""
        return _soqt.SoQtFlyViewer_getTypeId(self)

    @staticmethod
    def createInstance():
        r"""createInstance() -> void *"""
        return _soqt.SoQtFlyViewer_createInstance()

    def __init__(self, *args):
        r"""__init__(SoQtFlyViewer self, QWidget parent=None, char const * name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag=BUILD_ALL, SoQtViewer::Type type=BROWSER) -> SoQtFlyViewer"""
        _soqt.SoQtFlyViewer_swiginit(self, _soqt.new_SoQtFlyViewer(*args))
    __swig_destroy__ = _soqt.delete_SoQtFlyViewer

    def setViewing(self, enable):
        r"""setViewing(SoQtFlyViewer self, SbBool enable)"""
        return _soqt.SoQtFlyViewer_setViewing(self, enable)

    def viewAll(self):
        r"""viewAll(SoQtFlyViewer self)"""
        return _soqt.SoQtFlyViewer_viewAll(self)

    def resetToHomePosition(self):
        r"""resetToHomePosition(SoQtFlyViewer self)"""
        return _soqt.SoQtFlyViewer_resetToHomePosition(self)

    def setCamera(self, camera):
        r"""setCamera(SoQtFlyViewer self, SoCamera camera)"""
        return _soqt.SoQtFlyViewer_setCamera(self, camera)

    def setCursorEnabled(self, enable):
        r"""setCursorEnabled(SoQtFlyViewer self, SbBool enable)"""
        return _soqt.SoQtFlyViewer_setCursorEnabled(self, enable)

    def setCameraType(self, type):
        r"""setCameraType(SoQtFlyViewer self, SoType type)"""
        return _soqt.SoQtFlyViewer_setCameraType(self, type)

# Register SoQtFlyViewer in _soqt:
_soqt.SoQtFlyViewer_swigregister(SoQtFlyViewer)
class SoQtPopupMenu(object):
    r"""Proxy of C++ SoQtPopupMenu 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 createInstance():
        r"""createInstance() -> SoQtPopupMenu"""
        return _soqt.SoQtPopupMenu_createInstance()
    __swig_destroy__ = _soqt.delete_SoQtPopupMenu

    def newMenu(self, name, menuid=-1):
        r"""newMenu(SoQtPopupMenu self, char const * name, int menuid=-1) -> int"""
        return _soqt.SoQtPopupMenu_newMenu(self, name, menuid)

    def getMenu(self, name):
        r"""getMenu(SoQtPopupMenu self, char const * name) -> int"""
        return _soqt.SoQtPopupMenu_getMenu(self, name)

    def setMenuTitle(self, id, title):
        r"""setMenuTitle(SoQtPopupMenu self, int id, char const * title)"""
        return _soqt.SoQtPopupMenu_setMenuTitle(self, id, title)

    def getMenuTitle(self, id):
        r"""getMenuTitle(SoQtPopupMenu self, int id) -> char const *"""
        return _soqt.SoQtPopupMenu_getMenuTitle(self, id)

    def newMenuItem(self, name, itemid=-1):
        r"""newMenuItem(SoQtPopupMenu self, char const * name, int itemid=-1) -> int"""
        return _soqt.SoQtPopupMenu_newMenuItem(self, name, itemid)

    def getMenuItem(self, name):
        r"""getMenuItem(SoQtPopupMenu self, char const * name) -> int"""
        return _soqt.SoQtPopupMenu_getMenuItem(self, name)

    def setMenuItemTitle(self, itemid, title):
        r"""setMenuItemTitle(SoQtPopupMenu self, int itemid, char const * title)"""
        return _soqt.SoQtPopupMenu_setMenuItemTitle(self, itemid, title)

    def getMenuItemTitle(self, itemid):
        r"""getMenuItemTitle(SoQtPopupMenu self, int itemid) -> char const *"""
        return _soqt.SoQtPopupMenu_getMenuItemTitle(self, itemid)

    def setMenuItemEnabled(self, itemid, enabled):
        r"""setMenuItemEnabled(SoQtPopupMenu self, int itemid, SbBool enabled)"""
        return _soqt.SoQtPopupMenu_setMenuItemEnabled(self, itemid, enabled)

    def getMenuItemEnabled(self, itemid):
        r"""getMenuItemEnabled(SoQtPopupMenu self, int itemid) -> SbBool"""
        return _soqt.SoQtPopupMenu_getMenuItemEnabled(self, itemid)

    def setMenuItemMarked(self, itemid, marked):
        r"""setMenuItemMarked(SoQtPopupMenu self, int itemid, SbBool marked)"""
        return _soqt.SoQtPopupMenu_setMenuItemMarked(self, itemid, marked)

    def getMenuItemMarked(self, itemid):
        r"""getMenuItemMarked(SoQtPopupMenu self, int itemid) -> SbBool"""
        return _soqt.SoQtPopupMenu_getMenuItemMarked(self, itemid)

    def addMenu(self, menuid, submenuid, pos=-1):
        r"""addMenu(SoQtPopupMenu self, int menuid, int submenuid, int pos=-1)"""
        return _soqt.SoQtPopupMenu_addMenu(self, menuid, submenuid, pos)

    def addMenuItem(self, menuid, itemid, pos=-1):
        r"""addMenuItem(SoQtPopupMenu self, int menuid, int itemid, int pos=-1)"""
        return _soqt.SoQtPopupMenu_addMenuItem(self, menuid, itemid, pos)

    def addSeparator(self, menuid, pos=-1):
        r"""addSeparator(SoQtPopupMenu self, int menuid, int pos=-1)"""
        return _soqt.SoQtPopupMenu_addSeparator(self, menuid, pos)

    def removeMenu(self, menuid):
        r"""removeMenu(SoQtPopupMenu self, int menuid)"""
        return _soqt.SoQtPopupMenu_removeMenu(self, menuid)

    def removeMenuItem(self, itemid):
        r"""removeMenuItem(SoQtPopupMenu self, int itemid)"""
        return _soqt.SoQtPopupMenu_removeMenuItem(self, itemid)

    def popUp(self, inside, x, y):
        r"""popUp(SoQtPopupMenu self, QWidget inside, int x, int y)"""
        return _soqt.SoQtPopupMenu_popUp(self, inside, x, y)

    def newRadioGroup(self, groupid=-1):
        r"""newRadioGroup(SoQtPopupMenu self, int groupid=-1) -> int"""
        return _soqt.SoQtPopupMenu_newRadioGroup(self, groupid)

    def getRadioGroup(self, itemid):
        r"""getRadioGroup(SoQtPopupMenu self, int itemid) -> int"""
        return _soqt.SoQtPopupMenu_getRadioGroup(self, itemid)

    def getRadioGroupSize(self, groupid):
        r"""getRadioGroupSize(SoQtPopupMenu self, int groupid) -> int"""
        return _soqt.SoQtPopupMenu_getRadioGroupSize(self, groupid)

    def addRadioGroupItem(self, groupid, itemid):
        r"""addRadioGroupItem(SoQtPopupMenu self, int groupid, int itemid)"""
        return _soqt.SoQtPopupMenu_addRadioGroupItem(self, groupid, itemid)

    def removeRadioGroupItem(self, itemid):
        r"""removeRadioGroupItem(SoQtPopupMenu self, int itemid)"""
        return _soqt.SoQtPopupMenu_removeRadioGroupItem(self, itemid)

    def setRadioGroupMarkedItem(self, itemid):
        r"""setRadioGroupMarkedItem(SoQtPopupMenu self, int itemid)"""
        return _soqt.SoQtPopupMenu_setRadioGroupMarkedItem(self, itemid)

    def getRadioGroupMarkedItem(self, groupid):
        r"""getRadioGroupMarkedItem(SoQtPopupMenu self, int groupid) -> int"""
        return _soqt.SoQtPopupMenu_getRadioGroupMarkedItem(self, groupid)

    def addMenuSelectionCallback(self, callback, data):
        r"""addMenuSelectionCallback(SoQtPopupMenu self, SoQtMenuSelectionCallback * callback, void * data)"""
        return _soqt.SoQtPopupMenu_addMenuSelectionCallback(self, callback, data)

    def removeMenuSelectionCallback(self, callback, data):
        r"""removeMenuSelectionCallback(SoQtPopupMenu self, SoQtMenuSelectionCallback * callback, void * data)"""
        return _soqt.SoQtPopupMenu_removeMenuSelectionCallback(self, callback, data)

# Register SoQtPopupMenu in _soqt:
_soqt.SoQtPopupMenu_swigregister(SoQtPopupMenu)
class SoQtCursor(object):
    r"""Proxy of C++ SoQtCursor 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 _soqt.SoQtCursor_initClass()
    CUSTOM_BITMAP = _soqt.SoQtCursor_CUSTOM_BITMAP
    
    DEFAULT = _soqt.SoQtCursor_DEFAULT
    
    BUSY = _soqt.SoQtCursor_BUSY
    
    CROSSHAIR = _soqt.SoQtCursor_CROSSHAIR
    
    UPARROW = _soqt.SoQtCursor_UPARROW
    

    def __init__(self, *args):
        r"""
        __init__(SoQtCursor self) -> SoQtCursor
        __init__(SoQtCursor self, SoQtCursor::Shape const shape) -> SoQtCursor
        __init__(SoQtCursor self, SoQtCursor::CustomCursor const * cc) -> SoQtCursor
        __init__(SoQtCursor self, SoQtCursor cursor) -> SoQtCursor
        """
        _soqt.SoQtCursor_swiginit(self, _soqt.new_SoQtCursor(*args))
    __swig_destroy__ = _soqt.delete_SoQtCursor

    def getShape(self):
        r"""getShape(SoQtCursor self) -> SoQtCursor::Shape"""
        return _soqt.SoQtCursor_getShape(self)

    def setShape(self, shape):
        r"""setShape(SoQtCursor self, SoQtCursor::Shape const shape)"""
        return _soqt.SoQtCursor_setShape(self, shape)

    def getCustomCursor(self):
        r"""getCustomCursor(SoQtCursor self) -> SoQtCursor::CustomCursor const &"""
        return _soqt.SoQtCursor_getCustomCursor(self)

    @staticmethod
    def getZoomCursor():
        r"""getZoomCursor() -> SoQtCursor"""
        return _soqt.SoQtCursor_getZoomCursor()

    @staticmethod
    def getPanCursor():
        r"""getPanCursor() -> SoQtCursor"""
        return _soqt.SoQtCursor_getPanCursor()

    @staticmethod
    def getRotateCursor():
        r"""getRotateCursor() -> SoQtCursor"""
        return _soqt.SoQtCursor_getRotateCursor()

    @staticmethod
    def getBlankCursor():
        r"""getBlankCursor() -> SoQtCursor"""
        return _soqt.SoQtCursor_getBlankCursor()

# Register SoQtCursor in _soqt:
_soqt.SoQtCursor_swigregister(SoQtCursor)

