# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_soqt')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_soqt')
    _soqt = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_soqt', [dirname(__file__)])
        except ImportError:
            import _soqt
            return _soqt
        try:
            _mod = imp.load_module('_soqt', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _soqt = swig_import_helper()
    del swig_import_helper
else:
    import _soqt
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class charp(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _soqt.new_charp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_charp
    __del__ = lambda self: None

    def assign(self, value: 'char') -> "void":
        return _soqt.charp_assign(self, value)

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

    def cast(self) -> "char *":
        return _soqt.charp_cast(self)
    frompointer = staticmethod(_soqt.charp_frompointer)
charp_swigregister = _soqt.charp_swigregister
charp_swigregister(charp)
cast = _soqt.cast

def charp_frompointer(t: 'char *') -> "charp *":
    return _soqt.charp_frompointer(t)
charp_frompointer = _soqt.charp_frompointer

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

    def __init__(self):
        this = _soqt.new_intp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_intp
    __del__ = lambda self: None

    def assign(self, value: 'int') -> "void":
        return _soqt.intp_assign(self, value)

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

    def cast(self) -> "int *":
        return _soqt.intp_cast(self)
    frompointer = staticmethod(_soqt.intp_frompointer)
intp_swigregister = _soqt.intp_swigregister
intp_swigregister(intp)

def intp_frompointer(t: 'int *') -> "intp *":
    return _soqt.intp_frompointer(t)
intp_frompointer = _soqt.intp_frompointer

class longp(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _soqt.new_longp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_longp
    __del__ = lambda self: None

    def assign(self, value: 'long') -> "void":
        return _soqt.longp_assign(self, value)

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

    def cast(self) -> "long *":
        return _soqt.longp_cast(self)
    frompointer = staticmethod(_soqt.longp_frompointer)
longp_swigregister = _soqt.longp_swigregister
longp_swigregister(longp)

def longp_frompointer(t: 'long *') -> "longp *":
    return _soqt.longp_frompointer(t)
longp_frompointer = _soqt.longp_frompointer

class floatp(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _soqt.new_floatp()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_floatp
    __del__ = lambda self: None

    def assign(self, value: 'float') -> "void":
        return _soqt.floatp_assign(self, value)

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

    def cast(self) -> "float *":
        return _soqt.floatp_cast(self)
    frompointer = staticmethod(_soqt.floatp_frompointer)
floatp_swigregister = _soqt.floatp_swigregister
floatp_swigregister(floatp)

def floatp_frompointer(t: 'float *') -> "floatp *":
    return _soqt.floatp_frompointer(t)
floatp_frompointer = _soqt.floatp_frompointer

class doublep(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _soqt.new_doublep()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_doublep
    __del__ = lambda self: None

    def assign(self, value: 'double') -> "void":
        return _soqt.doublep_assign(self, value)

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

    def cast(self) -> "double *":
        return _soqt.doublep_cast(self)
    frompointer = staticmethod(_soqt.doublep_frompointer)
doublep_swigregister = _soqt.doublep_swigregister
doublep_swigregister(doublep)

def doublep_frompointer(t: 'double *') -> "doublep *":
    return _soqt.doublep_frompointer(t)
doublep_frompointer = _soqt.doublep_frompointer

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

    def __init__(self, *args):
        this = _soqt.new_SbDict(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SbDict
    __del__ = lambda self: None

    def applyToAll(self, *args) -> "void":
        return _soqt.SbDict_applyToAll(self, *args)

    def clear(self) -> "void":
        return _soqt.SbDict_clear(self)

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

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

    def makePList(self, keys: 'SbPList', values: 'SbPList') -> "void":
        return _soqt.SbDict_makePList(self, keys, values)

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

    def setHashingFunction(self, func: 'SbDictHashingFunc *') -> "void":
        return _soqt.SbDict_setHashingFunction(self, func)
SbDict_swigregister = _soqt.SbDict_swigregister
SbDict_swigregister(SbDict)

class SoType(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    fromName = staticmethod(_soqt.SoType_fromName)

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

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

    def isDerivedFrom(self, type: 'SoType') -> "SbBool":
        return _soqt.SoType_isDerivedFrom(self, type)
    getAllDerivedFrom = staticmethod(_soqt.SoType_getAllDerivedFrom)

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

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

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

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

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

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

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

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

    def __gt__(self, type: 'SoType') -> "SbBool":
        return _soqt.SoType___gt__(self, type)
    removeType = staticmethod(_soqt.SoType_removeType)
    init = staticmethod(_soqt.SoType_init)
    fromKey = staticmethod(_soqt.SoType_fromKey)
    badType = staticmethod(_soqt.SoType_badType)

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

    def makeInternal(self) -> "void":
        return _soqt.SoType_makeInternal(self)

    def isInternal(self) -> "SbBool":
        return _soqt.SoType_isInternal(self)
    getNumTypes = staticmethod(_soqt.SoType_getNumTypes)

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

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

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

def SoType_fromName(name: 'SbName') -> "SoType":
    return _soqt.SoType_fromName(name)
SoType_fromName = _soqt.SoType_fromName

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

def SoType_removeType(name: 'SbName') -> "SbBool":
    return _soqt.SoType_removeType(name)
SoType_removeType = _soqt.SoType_removeType

def SoType_init() -> "void":
    return _soqt.SoType_init()
SoType_init = _soqt.SoType_init

def SoType_fromKey(key: 'uint16_t') -> "SoType":
    return _soqt.SoType_fromKey(key)
SoType_fromKey = _soqt.SoType_fromKey

def SoType_badType() -> "SoType":
    return _soqt.SoType_badType()
SoType_badType = _soqt.SoType_badType

def SoType_getNumTypes() -> "int":
    return _soqt.SoType_getNumTypes()
SoType_getNumTypes = _soqt.SoType_getNumTypes

class SbPList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _soqt.new_SbPList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SbPList
    __del__ = lambda self: None

    def copy(self, l: 'SbPList') -> "void":
        return _soqt.SbPList_copy(self, l)

    def fit(self) -> "void":
        return _soqt.SbPList_fit(self)

    def append(self, item: 'void *') -> "void":
        return _soqt.SbPList_append(self, item)

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

    def insert(self, item: 'void *', insertbefore: 'int const') -> "void":
        return _soqt.SbPList_insert(self, item, insertbefore)

    def removeItem(self, item: 'void *') -> "void":
        return _soqt.SbPList_removeItem(self, item)

    def remove(self, index: 'int const') -> "void":
        return _soqt.SbPList_remove(self, index)

    def removeFast(self, index: 'int const') -> "void":
        return _soqt.SbPList_removeFast(self, index)

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

    def truncate(self, length: 'int const', fit: 'int const'=0) -> "void":
        return _soqt.SbPList_truncate(self, length, fit)

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

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

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

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

    def set(self, index: 'int const', item: 'void *') -> "void":
        return _soqt.SbPList_set(self, index, item)

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

    def __setitem__(self, i: 'int', val: 'void *') -> "void":
        return _soqt.SbPList___setitem__(self, i, val)

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

SbPList_swigregister = _soqt.SbPList_swigregister
SbPList_swigregister(SbPList)

class SbIntList(SbPList):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _soqt.new_SbIntList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def append(self, item: 'int const') -> "void":
        return _soqt.SbIntList_append(self, item)

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

    def insert(self, item: 'int const', addbefore: 'int const') -> "void":
        return _soqt.SbIntList_insert(self, item, addbefore)

    def __setitem__(self, i: 'int const', value: 'int *') -> "void":
        return _soqt.SbIntList___setitem__(self, i, value)

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

    def get(self, i: 'int const') -> "int":
        return _soqt.SbIntList_get(self, i)
    __swig_destroy__ = _soqt.delete_SbIntList
    __del__ = lambda self: None
SbIntList_swigregister = _soqt.SbIntList_swigregister
SbIntList_swigregister(SbIntList)

class SbString(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        this = _soqt.new_SbString(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SbString
    __del__ = lambda self: None
    hash = staticmethod(_soqt.SbString_hash)

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

    def makeEmpty(self, freeold: 'SbBool'=1) -> "void":
        return _soqt.SbString_makeEmpty(self, freeold)

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

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

    def deleteSubString(self, startidx: 'int', endidx: 'int'=-1) -> "void":
        return _soqt.SbString_deleteSubString(self, startidx, endidx)

    def addIntString(self, value: 'int const') -> "void":
        return _soqt.SbString_addIntString(self, value)

    def __iadd__(self, *args) -> "SbString &":
        return _soqt.SbString___iadd__(self, *args)

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

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

    def apply(self, func: 'char (*)(char)') -> "void":
        return _soqt.SbString_apply(self, func)

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

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

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

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

    def _print(self, fp: 'std::FILE *') -> "void":
        return _soqt.SbString__print(self, fp)

    def __eq__(self, *args) -> "int":
        return _soqt.SbString___eq__(self, *args)

    def __nq__(self, *args) -> "int":
        return _soqt.SbString___nq__(self, *args)

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

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


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

def SbString_hash(*args) -> "uint32_t":
    return _soqt.SbString_hash(*args)
SbString_hash = _soqt.SbString_hash

class SbName(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        this = _soqt.new_SbName(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SbName
    __del__ = lambda self: None

    def getString(self) -> "char const *":
        return _soqt.SbName_getString(self)

    def getLength(self) -> "int":
        return _soqt.SbName_getLength(self)
    isIdentStartChar = staticmethod(_soqt.SbName_isIdentStartChar)
    isIdentChar = staticmethod(_soqt.SbName_isIdentChar)
    isBaseNameStartChar = staticmethod(_soqt.SbName_isBaseNameStartChar)
    isBaseNameChar = staticmethod(_soqt.SbName_isBaseNameChar)
    empty = staticmethod(_soqt.SbName_empty)

    def __eq__(self, *args) -> "int":
        return _soqt.SbName___eq__(self, *args)

    def __nq__(self, *args) -> "int":
        return _soqt.SbName___nq__(self, *args)

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

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


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

def SbName_isIdentStartChar(c: 'char const') -> "SbBool":
    return _soqt.SbName_isIdentStartChar(c)
SbName_isIdentStartChar = _soqt.SbName_isIdentStartChar

def SbName_isIdentChar(c: 'char const') -> "SbBool":
    return _soqt.SbName_isIdentChar(c)
SbName_isIdentChar = _soqt.SbName_isIdentChar

def SbName_isBaseNameStartChar(c: 'char const') -> "SbBool":
    return _soqt.SbName_isBaseNameStartChar(c)
SbName_isBaseNameStartChar = _soqt.SbName_isBaseNameStartChar

def SbName_isBaseNameChar(c: 'char const') -> "SbBool":
    return _soqt.SbName_isBaseNameChar(c)
SbName_isBaseNameChar = _soqt.SbName_isBaseNameChar

def SbName_empty() -> "SbName const &":
    return _soqt.SbName_empty()
SbName_empty = _soqt.SbName_empty

class SoError(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        this = _soqt.new_SoError()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoError
    __del__ = lambda self: None
    setHandlerCallback = staticmethod(_soqt.SoError_setHandlerCallback)
    getHandlerCallback = staticmethod(_soqt.SoError_getHandlerCallback)
    getHandlerData = staticmethod(_soqt.SoError_getHandlerData)

    def getDebugString(self) -> "SbString const &":
        return _soqt.SoError_getDebugString(self)
    getClassTypeId = staticmethod(_soqt.SoError_getClassTypeId)

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

    def isOfType(self, type: 'SoType') -> "SbBool":
        return _soqt.SoError_isOfType(self, type)
    post = staticmethod(_soqt.SoError_post)
    getString = staticmethod(_soqt.SoError_getString)
    initClass = staticmethod(_soqt.SoError_initClass)
    initClasses = staticmethod(_soqt.SoError_initClasses)
SoError_swigregister = _soqt.SoError_swigregister
SoError_swigregister(SoError)

def SoError_setHandlerCallback(func: 'SoErrorCB *const', data: 'void *const') -> "void":
    return _soqt.SoError_setHandlerCallback(func, data)
SoError_setHandlerCallback = _soqt.SoError_setHandlerCallback

def SoError_getHandlerCallback() -> "SoErrorCB *":
    return _soqt.SoError_getHandlerCallback()
SoError_getHandlerCallback = _soqt.SoError_getHandlerCallback

def SoError_getHandlerData() -> "void *":
    return _soqt.SoError_getHandlerData()
SoError_getHandlerData = _soqt.SoError_getHandlerData

def SoError_getClassTypeId() -> "SoType":
    return _soqt.SoError_getClassTypeId()
SoError_getClassTypeId = _soqt.SoError_getClassTypeId

def SoError_post(format: 'char const *const') -> "void":
    return _soqt.SoError_post(format)
SoError_post = _soqt.SoError_post

def SoError_getString(*args) -> "SbString":
    return _soqt.SoError_getString(*args)
SoError_getString = _soqt.SoError_getString

def SoError_initClass() -> "void":
    return _soqt.SoError_initClass()
SoError_initClass = _soqt.SoError_initClass

def SoError_initClasses() -> "void":
    return _soqt.SoError_initClasses()
SoError_initClasses = _soqt.SoError_initClasses

class SoDebugError(SoError):
    thisown = _swig_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
    setHandlerCallback = staticmethod(_soqt.SoDebugError_setHandlerCallback)
    getHandlerCallback = staticmethod(_soqt.SoDebugError_getHandlerCallback)
    getHandlerData = staticmethod(_soqt.SoDebugError_getHandlerData)
    getClassTypeId = staticmethod(_soqt.SoDebugError_getClassTypeId)

    def getTypeId(self) -> "SoType":
        return _soqt.SoDebugError_getTypeId(self)

    def getSeverity(self) -> "SoDebugError::Severity":
        return _soqt.SoDebugError_getSeverity(self)
    post = staticmethod(_soqt.SoDebugError_post)
    postWarning = staticmethod(_soqt.SoDebugError_postWarning)
    postInfo = staticmethod(_soqt.SoDebugError_postInfo)
    initClass = staticmethod(_soqt.SoDebugError_initClass)

    def __init__(self):
        """__init__(SoDebugError self) -> SoDebugError"""
        this = _soqt.new_SoDebugError()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoDebugError
    __del__ = lambda self: None
SoDebugError_swigregister = _soqt.SoDebugError_swigregister
SoDebugError_swigregister(SoDebugError)

def SoDebugError_setHandlerCallback(function: 'SoErrorCB *const', data: 'void *const') -> "void":
    return _soqt.SoDebugError_setHandlerCallback(function, data)
SoDebugError_setHandlerCallback = _soqt.SoDebugError_setHandlerCallback

def SoDebugError_getHandlerCallback() -> "SoErrorCB *":
    return _soqt.SoDebugError_getHandlerCallback()
SoDebugError_getHandlerCallback = _soqt.SoDebugError_getHandlerCallback

def SoDebugError_getHandlerData() -> "void *":
    return _soqt.SoDebugError_getHandlerData()
SoDebugError_getHandlerData = _soqt.SoDebugError_getHandlerData

def SoDebugError_getClassTypeId() -> "SoType":
    return _soqt.SoDebugError_getClassTypeId()
SoDebugError_getClassTypeId = _soqt.SoDebugError_getClassTypeId

def SoDebugError_post(source: 'char const *const', format: 'char const *const') -> "void":
    return _soqt.SoDebugError_post(source, format)
SoDebugError_post = _soqt.SoDebugError_post

def SoDebugError_postWarning(source: 'char const *const', format: 'char const *const') -> "void":
    return _soqt.SoDebugError_postWarning(source, format)
SoDebugError_postWarning = _soqt.SoDebugError_postWarning

def SoDebugError_postInfo(source: 'char const *const', format: 'char const *const') -> "void":
    return _soqt.SoDebugError_postInfo(source, format)
SoDebugError_postInfo = _soqt.SoDebugError_postInfo

def SoDebugError_initClass() -> "void":
    return _soqt.SoDebugError_initClass()
SoDebugError_initClass = _soqt.SoDebugError_initClass

class SbVec2s(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _soqt.new_SbVec2s(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setValue(self, *args) -> "SbVec2s &":
        return _soqt.SbVec2s_setValue(self, *args)

    def getValue(self) -> "void":
        return _soqt.SbVec2s_getValue(self)

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

    def negate(self) -> "void":
        return _soqt.SbVec2s_negate(self)

    def __imul__(self, *args) -> "SbVec2s &":
        return _soqt.SbVec2s___imul__(self, *args)

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



    def __iadd__(self, v: 'SbVec2s') -> "SbVec2s &":
        return _soqt.SbVec2s___iadd__(self, v)

    def __isub__(self, v: 'SbVec2s') -> "SbVec2s &":
        return _soqt.SbVec2s___isub__(self, v)

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

    def toString(self) -> "SbString":
        return _soqt.SbVec2s_toString(self)

    def fromString(self, str: 'SbString') -> "SbBool":
        return _soqt.SbVec2s_fromString(self, str)

    def output(self, fp: 'FILE *') -> "void":
        return _soqt.SbVec2s_output(self, fp)

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

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

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

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

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

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

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

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

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

    def __setitem__(self, i: 'int', value: 'short') -> "void":
        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
    __del__ = lambda self: None
SbVec2s_swigregister = _soqt.SbVec2s_swigregister
SbVec2s_swigregister(SbVec2s)

class SbTime(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _soqt.new_SbTime(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    getTimeOfDay = staticmethod(_soqt.SbTime_getTimeOfDay)

    def setToTimeOfDay(self) -> "void":
        return _soqt.SbTime_setToTimeOfDay(self)
    zero = staticmethod(_soqt.SbTime_zero)
    max = staticmethod(_soqt.SbTime_max)
    maxTime = staticmethod(_soqt.SbTime_maxTime)
    sleep = staticmethod(_soqt.SbTime_sleep)

    def setValue(self, *args) -> "void":
        return _soqt.SbTime_setValue(self, *args)

    def setMsecValue(self, msec: 'unsigned long const') -> "void":
        return _soqt.SbTime_setMsecValue(self, msec)

    def getValue(self, *args) -> "void":
        return _soqt.SbTime_getValue(self, *args)

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

    def format(self, *args) -> "SbString":
        return _soqt.SbTime_format(self, *args)

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

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

    def __iadd__(self, tm: 'SbTime') -> "SbTime &":
        return _soqt.SbTime___iadd__(self, tm)

    def __isub__(self, tm: 'SbTime') -> "SbTime &":
        return _soqt.SbTime___isub__(self, tm)

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

    def __imul__(self, s: 'double const') -> "SbTime &":
        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: 'SbTime') -> "SbTime":
        return _soqt.SbTime___mod__(self, tm)

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

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

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

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

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

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

    def output(self, fp: 'FILE *') -> "void":
        return _soqt.SbTime_output(self, fp)

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

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

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

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

    def __div__(self, d: 'double const') -> "SbTime":
        return _soqt.SbTime___div__(self, d)
    __swig_destroy__ = _soqt.delete_SbTime
    __del__ = lambda self: None
SbTime_swigregister = _soqt.SbTime_swigregister
SbTime_swigregister(SbTime)

def SbTime_getTimeOfDay() -> "SbTime":
    return _soqt.SbTime_getTimeOfDay()
SbTime_getTimeOfDay = _soqt.SbTime_getTimeOfDay

def SbTime_zero() -> "SbTime":
    return _soqt.SbTime_zero()
SbTime_zero = _soqt.SbTime_zero

def SbTime_max() -> "SbTime":
    return _soqt.SbTime_max()
SbTime_max = _soqt.SbTime_max

def SbTime_maxTime() -> "SbTime":
    return _soqt.SbTime_maxTime()
SbTime_maxTime = _soqt.SbTime_maxTime

def SbTime_sleep(msec: 'int') -> "void":
    return _soqt.SbTime_sleep(msec)
SbTime_sleep = _soqt.SbTime_sleep

class SoEvent(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    getClassTypeId = staticmethod(_soqt.SoEvent_getClassTypeId)

    def getTypeId(self) -> "SoType":
        return _soqt.SoEvent_getTypeId(self)
    initClass = staticmethod(_soqt.SoEvent_initClass)

    def __init__(self):
        this = _soqt.new_SoEvent()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoEvent
    __del__ = lambda self: None

    def isOfType(self, type: 'SoType') -> "SbBool":
        return _soqt.SoEvent_isOfType(self, type)

    def setTime(self, t: 'SbTime') -> "void":
        return _soqt.SoEvent_setTime(self, t)

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

    def setPosition(self, p: 'SbVec2s') -> "void":
        return _soqt.SoEvent_setPosition(self, p)

    def getPosition(self, *args) -> "SbVec2s const":
        return _soqt.SoEvent_getPosition(self, *args)

    def getNormalizedPosition(self, vpRgn: 'SbViewportRegion') -> "SbVec2f const":
        return _soqt.SoEvent_getNormalizedPosition(self, vpRgn)

    def setShiftDown(self, isDown: 'SbBool') -> "void":
        return _soqt.SoEvent_setShiftDown(self, isDown)

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

    def setCtrlDown(self, isDown: 'SbBool') -> "void":
        return _soqt.SoEvent_setCtrlDown(self, isDown)

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

    def setAltDown(self, isDown: 'SbBool') -> "void":
        return _soqt.SoEvent_setAltDown(self, isDown)

    def wasAltDown(self) -> "SbBool":
        return _soqt.SoEvent_wasAltDown(self)
SoEvent_swigregister = _soqt.SoEvent_swigregister
SoEvent_swigregister(SoEvent)

def SoEvent_getClassTypeId() -> "SoType":
    return _soqt.SoEvent_getClassTypeId()
SoEvent_getClassTypeId = _soqt.SoEvent_getClassTypeId

def SoEvent_initClass() -> "void":
    return _soqt.SoEvent_initClass()
SoEvent_initClass = _soqt.SoEvent_initClass

class SoNotRec(object):
    thisown = _swig_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: 'SoBase'):
        this = _soqt.new_SoNotRec(notifbase)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setType(self, type: 'SoNotRec::Type const') -> "void":
        return _soqt.SoNotRec_setType(self, type)

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

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

    def getPrevious(self) -> "SoNotRec const *":
        return _soqt.SoNotRec_getPrevious(self)

    def setPrevious(self, prev: 'SoNotRec') -> "void":
        return _soqt.SoNotRec_setPrevious(self, prev)

    def output(self, file: 'FILE *const') -> "void":
        return _soqt.SoNotRec_output(self, file)

    def getOperationType(self) -> "SoNotRec::OperationType":
        return _soqt.SoNotRec_getOperationType(self)

    def getIndex(self) -> "int":
        return _soqt.SoNotRec_getIndex(self)

    def getFieldNumIndices(self) -> "int":
        return _soqt.SoNotRec_getFieldNumIndices(self)

    def getGroupChild(self) -> "SoBase const *":
        return _soqt.SoNotRec_getGroupChild(self)

    def getGroupPrevChild(self) -> "SoBase const *":
        return _soqt.SoNotRec_getGroupPrevChild(self)

    def setOperationType(self, opType: 'SoNotRec::OperationType const') -> "void":
        return _soqt.SoNotRec_setOperationType(self, opType)

    def setIndex(self, idx: 'int const') -> "void":
        return _soqt.SoNotRec_setIndex(self, idx)

    def setFieldNumIndices(self, fldnumind: 'int const') -> "void":
        return _soqt.SoNotRec_setFieldNumIndices(self, fldnumind)

    def setGroupChild(self, gc: 'SoBase') -> "void":
        return _soqt.SoNotRec_setGroupChild(self, gc)

    def setGroupPrevChild(self, pc: 'SoBase') -> "void":
        return _soqt.SoNotRec_setGroupPrevChild(self, pc)
    __swig_destroy__ = _soqt.delete_SoNotRec
    __del__ = lambda self: None
SoNotRec_swigregister = _soqt.SoNotRec_swigregister
SoNotRec_swigregister(SoNotRec)

class SoNotList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _soqt.new_SoNotList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def append(self, *args) -> "void":
        return _soqt.SoNotList_append(self, *args)

    def setLastType(self, type: 'SoNotRec::Type const') -> "void":
        return _soqt.SoNotList_setLastType(self, type)

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

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

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

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

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

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

    def output(self, *args) -> "void":
        return _soqt.SoNotList_output(self, *args)
    __swig_destroy__ = _soqt.delete_SoNotList
    __del__ = lambda self: None
SoNotList_swigregister = _soqt.SoNotList_swigregister
SoNotList_swigregister(SoNotList)

class SoField(object):
    thisown = _swig_property(lambda x: 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
    __del__ = lambda self: None
    initClass = staticmethod(_soqt.SoField_initClass)
    initClasses = staticmethod(_soqt.SoField_initClasses)
    cleanupClass = staticmethod(_soqt.SoField_cleanupClass)

    def setIgnored(self, ignore: 'SbBool') -> "void":
        return _soqt.SoField_setIgnored(self, ignore)

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

    def setDefault(self, defaultVal: 'SbBool') -> "void":
        return _soqt.SoField_setDefault(self, defaultVal)

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

    def getTypeId(self) -> "SoType":
        return _soqt.SoField_getTypeId(self)
    getClassTypeId = staticmethod(_soqt.SoField_getClassTypeId)

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

    def enableConnection(self, flag: 'SbBool') -> "void":
        return _soqt.SoField_enableConnection(self, flag)

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

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

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

    def connectFrom(self, *args) -> "SbBool":
        return _soqt.SoField_connectFrom(self, *args)

    def appendConnection(self, *args) -> "SbBool":
        return _soqt.SoField_appendConnection(self, *args)

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

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

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

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

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

    def disconnect(self, *args) -> "void":
        return _soqt.SoField_disconnect(self, *args)

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

    def setContainer(self, cont: 'SoFieldContainer') -> "void":
        return _soqt.SoField_setContainer(self, cont)

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

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

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

    def touch(self) -> "void":
        return _soqt.SoField_touch(self)

    def startNotify(self) -> "void":
        return _soqt.SoField_startNotify(self)

    def notify(self, nlist: 'SoNotList') -> "void":
        return _soqt.SoField_notify(self, nlist)

    def enableNotify(self, on: 'SbBool') -> "SbBool":
        return _soqt.SoField_enableNotify(self, on)

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

    def addAuditor(self, f: 'void *', type: 'SoNotRec::Type') -> "void":
        return _soqt.SoField_addAuditor(self, f, type)

    def removeAuditor(self, f: 'void *', type: 'SoNotRec::Type') -> "void":
        return _soqt.SoField_removeAuditor(self, f, type)

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

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

    def connectionStatusChanged(self, numconnections: 'int') -> "void":
        return _soqt.SoField_connectionStatusChanged(self, numconnections)

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

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

    def copyFrom(self, f: 'SoField') -> "void":
        return _soqt.SoField_copyFrom(self, f)

    def fixCopy(self, copyconnections: 'SbBool') -> "void":
        return _soqt.SoField_fixCopy(self, copyconnections)

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

    def copyConnection(self, fromfield: 'SoField') -> "void":
        return _soqt.SoField_copyConnection(self, fromfield)

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

    def write(self, out: 'SoOutput', name: 'SbName') -> "void":
        return _soqt.SoField_write(self, out, name)

    def countWriteRefs(self, out: 'SoOutput') -> "void":
        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: 'int') -> "void":
        return _soqt.SoField_setFieldType(self, type)

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

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

    def setDirty(self, dirty: 'SbBool') -> "void":
        return _soqt.SoField_setDirty(self, dirty)

    def evaluate(self) -> "void":
        return _soqt.SoField_evaluate(self)

    def get(self) -> "SbString":
        return _soqt.SoField_get(self)
SoField_swigregister = _soqt.SoField_swigregister
SoField_swigregister(SoField)

def SoField_initClass() -> "void":
    return _soqt.SoField_initClass()
SoField_initClass = _soqt.SoField_initClass

def SoField_initClasses() -> "void":
    return _soqt.SoField_initClasses()
SoField_initClasses = _soqt.SoField_initClasses

def SoField_cleanupClass() -> "void":
    return _soqt.SoField_cleanupClass()
SoField_cleanupClass = _soqt.SoField_cleanupClass

def SoField_getClassTypeId() -> "SoType":
    return _soqt.SoField_getClassTypeId()
SoField_getClassTypeId = _soqt.SoField_getClassTypeId

class SoSField(SoField):
    thisown = _swig_property(lambda x: 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
    __del__ = lambda self: None
    initClass = staticmethod(_soqt.SoSField_initClass)
    getClassTypeId = staticmethod(_soqt.SoSField_getClassTypeId)
    atexit_cleanup = staticmethod(_soqt.SoSField_atexit_cleanup)
SoSField_swigregister = _soqt.SoSField_swigregister
SoSField_swigregister(SoSField)

def SoSField_initClass() -> "void":
    return _soqt.SoSField_initClass()
SoSField_initClass = _soqt.SoSField_initClass

def SoSField_getClassTypeId() -> "SoType":
    return _soqt.SoSField_getClassTypeId()
SoSField_getClassTypeId = _soqt.SoSField_getClassTypeId

def SoSField_atexit_cleanup() -> "void":
    return _soqt.SoSField_atexit_cleanup()
SoSField_atexit_cleanup = _soqt.SoSField_atexit_cleanup

class SoMField(SoField):
    thisown = _swig_property(lambda x: 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
    __del__ = lambda self: None
    getClassTypeId = staticmethod(_soqt.SoMField_getClassTypeId)
    atexit_cleanup = staticmethod(_soqt.SoMField_atexit_cleanup)

    def getNum(self) -> "int":
        return _soqt.SoMField_getNum(self)

    def setNum(self, num: 'int const') -> "void":
        return _soqt.SoMField_setNum(self, num)

    def deleteValues(self, start: 'int', num: 'int'=-1) -> "void":
        return _soqt.SoMField_deleteValues(self, start, num)

    def insertSpace(self, start: 'int', num: 'int') -> "void":
        return _soqt.SoMField_insertSpace(self, start, num)

    def set1(self, index: 'int const', valuestring: 'char const *const') -> "SbBool":
        return _soqt.SoMField_set1(self, index, valuestring)
    initClass = staticmethod(_soqt.SoMField_initClass)

    def enableDeleteValues(self) -> "void":
        return _soqt.SoMField_enableDeleteValues(self)

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

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


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

    def get1(self, index: 'int const') -> "SbString":
        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)


SoMField_swigregister = _soqt.SoMField_swigregister
SoMField_swigregister(SoMField)

def SoMField_getClassTypeId() -> "SoType":
    return _soqt.SoMField_getClassTypeId()
SoMField_getClassTypeId = _soqt.SoMField_getClassTypeId

def SoMField_atexit_cleanup() -> "void":
    return _soqt.SoMField_atexit_cleanup()
SoMField_atexit_cleanup = _soqt.SoMField_atexit_cleanup

def SoMField_initClass() -> "void":
    return _soqt.SoMField_initClass()
SoMField_initClass = _soqt.SoMField_initClass

import pivy.coin
class QEvent(object):
    """Proxy of C++ QEvent class."""

    thisown = _swig_property(lambda x: x.this.own(), 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
    __del__ = lambda self: None
QEvent_swigregister = _soqt.QEvent_swigregister
QEvent_swigregister(QEvent)

class QWidget(object):
    """Proxy of C++ QWidget class."""

    thisown = _swig_property(lambda x: x.this.own(), 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
    __del__ = lambda self: None
QWidget_swigregister = _soqt.QWidget_swigregister
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):
    """Proxy of C++ SoQtObject class."""

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

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtObject_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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


    def init() -> "void":
        """init()"""
        return _soqt.SoQtObject_init()

    init = staticmethod(init)
    __swig_destroy__ = _soqt.delete_SoQtObject
    __del__ = lambda self: None
SoQtObject_swigregister = _soqt.SoQtObject_swigregister
SoQtObject_swigregister(SoQtObject)

def SoQtObject_initClass() -> "void":
    """SoQtObject_initClass()"""
    return _soqt.SoQtObject_initClass()

def SoQtObject_getClassTypeId() -> "SoType":
    """SoQtObject_getClassTypeId() -> SoType"""
    return _soqt.SoQtObject_getClassTypeId()

def SoQtObject_init() -> "void":
    """SoQtObject_init()"""
    return _soqt.SoQtObject_init()

SOQT_SUN_CC_4_0_SOTYPE_INIT_BUG = _soqt.SOQT_SUN_CC_4_0_SOTYPE_INIT_BUG
class SoQtDevice(SoQtObject):
    """Proxy of C++ SoQtDevice class."""

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

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtDevice_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

    def getTypeId(self) -> "SoType":
        """getTypeId(SoQtDevice self) -> SoType"""
        return _soqt.SoQtDevice_getTypeId(self)

    __swig_destroy__ = _soqt.delete_SoQtDevice
    __del__ = lambda self: None

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


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


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


    def setWindowSize(self, size: 'SbVec2s') -> "void":
        """setWindowSize(SoQtDevice self, SbVec2s size)"""
        return _soqt.SoQtDevice_setWindowSize(self, size)


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


    def initClasses() -> "void":
        """initClasses()"""
        return _soqt.SoQtDevice_initClasses()

    initClasses = staticmethod(initClasses)
SoQtDevice_swigregister = _soqt.SoQtDevice_swigregister
SoQtDevice_swigregister(SoQtDevice)

def SoQtDevice_initClass() -> "void":
    """SoQtDevice_initClass()"""
    return _soqt.SoQtDevice_initClass()

def SoQtDevice_getClassTypeId() -> "SoType":
    """SoQtDevice_getClassTypeId() -> SoType"""
    return _soqt.SoQtDevice_getClassTypeId()

def SoQtDevice_initClasses() -> "void":
    """SoQtDevice_initClasses()"""
    return _soqt.SoQtDevice_initClasses()

class SoQtKeyboard(SoQtDevice):
    """Proxy of C++ SoQtKeyboard class."""

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtKeyboard_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def createInstance() -> "void *":
        """createInstance() -> void *"""
        return _soqt.SoQtKeyboard_createInstance()

    createInstance = staticmethod(createInstance)
    KEY_PRESS = _soqt.SoQtKeyboard_KEY_PRESS
    KEY_RELEASE = _soqt.SoQtKeyboard_KEY_RELEASE
    ALL_EVENTS = _soqt.SoQtKeyboard_ALL_EVENTS

    def __init__(self, *args):
        """
        __init__(SoQtKeyboard self, int eventmask) -> SoQtKeyboard
        __init__(SoQtKeyboard self) -> SoQtKeyboard
        """
        this = _soqt.new_SoQtKeyboard(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtKeyboard
    __del__ = lambda self: None

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


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


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

SoQtKeyboard_swigregister = _soqt.SoQtKeyboard_swigregister
SoQtKeyboard_swigregister(SoQtKeyboard)

def SoQtKeyboard_initClass() -> "void":
    """SoQtKeyboard_initClass()"""
    return _soqt.SoQtKeyboard_initClass()

def SoQtKeyboard_getClassTypeId() -> "SoType":
    """SoQtKeyboard_getClassTypeId() -> SoType"""
    return _soqt.SoQtKeyboard_getClassTypeId()

def SoQtKeyboard_createInstance() -> "void *":
    """SoQtKeyboard_createInstance() -> void *"""
    return _soqt.SoQtKeyboard_createInstance()

class SoQtMouse(SoQtDevice):
    """Proxy of C++ SoQtMouse class."""

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtMouse_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def createInstance() -> "void *":
        """createInstance() -> void *"""
        return _soqt.SoQtMouse_createInstance()

    createInstance = staticmethod(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):
        """
        __init__(SoQtMouse self, int eventmask) -> SoQtMouse
        __init__(SoQtMouse self) -> SoQtMouse
        """
        this = _soqt.new_SoQtMouse(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtMouse
    __del__ = lambda self: None

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


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


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

SoQtMouse_swigregister = _soqt.SoQtMouse_swigregister
SoQtMouse_swigregister(SoQtMouse)

def SoQtMouse_initClass() -> "void":
    """SoQtMouse_initClass()"""
    return _soqt.SoQtMouse_initClass()

def SoQtMouse_getClassTypeId() -> "SoType":
    """SoQtMouse_getClassTypeId() -> SoType"""
    return _soqt.SoQtMouse_getClassTypeId()

def SoQtMouse_createInstance() -> "void *":
    """SoQtMouse_createInstance() -> void *"""
    return _soqt.SoQtMouse_createInstance()

class SoQt(object):
    """Proxy of C++ SoQt class."""

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

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

    def init(*args) -> "void":
        """
        init(char const * appname, char const * classname) -> QWidget
        init(char const * appname) -> QWidget
        init(int & argc, char ** argv, char const * appname, char const * classname) -> QWidget
        init(int & argc, char ** argv, char const * appname) -> QWidget
        init(QWidget toplevelwidget)
        """
        return _soqt.SoQt_init(*args)

    init = staticmethod(init)

    def exitMainLoop() -> "void":
        """exitMainLoop()"""
        return _soqt.SoQt_exitMainLoop()

    exitMainLoop = staticmethod(exitMainLoop)

    def done() -> "void":
        """done()"""
        return _soqt.SoQt_done()

    done = staticmethod(done)

    def getTopLevelWidget() -> "QWidget *":
        """getTopLevelWidget() -> QWidget"""
        return _soqt.SoQt_getTopLevelWidget()

    getTopLevelWidget = staticmethod(getTopLevelWidget)

    def getShellWidget(w: 'QWidget') -> "QWidget *":
        """getShellWidget(QWidget w) -> QWidget"""
        return _soqt.SoQt_getShellWidget(w)

    getShellWidget = staticmethod(getShellWidget)

    def show(widget: 'QWidget') -> "void":
        """show(QWidget widget)"""
        return _soqt.SoQt_show(widget)

    show = staticmethod(show)

    def hide(widget: 'QWidget') -> "void":
        """hide(QWidget widget)"""
        return _soqt.SoQt_hide(widget)

    hide = staticmethod(hide)

    def setWidgetSize(widget: 'QWidget', size: 'SbVec2s') -> "void":
        """setWidgetSize(QWidget widget, SbVec2s size)"""
        return _soqt.SoQt_setWidgetSize(widget, size)

    setWidgetSize = staticmethod(setWidgetSize)

    def getWidgetSize(widget: 'QWidget') -> "SbVec2s":
        """getWidgetSize(QWidget widget) -> SbVec2s"""
        return _soqt.SoQt_getWidgetSize(widget)

    getWidgetSize = staticmethod(getWidgetSize)

    def createSimpleErrorDialog(widget: 'QWidget', title: 'char const *', string1: 'char const *', string2: 'char const *'=None) -> "void":
        """
        createSimpleErrorDialog(QWidget widget, char const * title, char const * string1, char const * string2=None)
        createSimpleErrorDialog(QWidget widget, char const * title, char const * string1)
        """
        return _soqt.SoQt_createSimpleErrorDialog(widget, title, string1, string2)

    createSimpleErrorDialog = staticmethod(createSimpleErrorDialog)

    def getVersionInfo(major: 'int *'=None, minor: 'int *'=None, micro: 'int *'=None) -> "void":
        """
        getVersionInfo(int * major=None, int * minor=None, int * micro=None)
        getVersionInfo(int * major=None, int * minor=None)
        getVersionInfo(int * major=None)
        getVersionInfo()
        """
        return _soqt.SoQt_getVersionInfo(major, minor, micro)

    getVersionInfo = staticmethod(getVersionInfo)

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

    getVersionString = staticmethod(getVersionString)

    def getVersionToolkitString() -> "char const *":
        """getVersionToolkitString() -> char const *"""
        return _soqt.SoQt_getVersionToolkitString()

    getVersionToolkitString = staticmethod(getVersionToolkitString)
    UNSPECIFIED_ERROR = _soqt.SoQt_UNSPECIFIED_ERROR
    NO_OPENGL_CANVAS = _soqt.SoQt_NO_OPENGL_CANVAS
    INTERNAL_ASSERT = _soqt.SoQt_INTERNAL_ASSERT

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

    setFatalErrorHandler = staticmethod(setFatalErrorHandler)

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

    isDebugLibrary = staticmethod(isDebugLibrary)

    def isCompatible(major: 'unsigned int', minor: 'unsigned int') -> "SbBool":
        """isCompatible(unsigned int major, unsigned int minor) -> SbBool"""
        return _soqt.SoQt_isCompatible(major, minor)

    isCompatible = staticmethod(isCompatible)
    DLL = _soqt.SoQt_DLL
    LIB = _soqt.SoQt_LIB
    UNKNOWN = _soqt.SoQt_UNKNOWN

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

    getABIType = staticmethod(getABIType)

    def lockGL() -> "void":
        """lockGL()"""
        return _soqt.SoQt_lockGL()

    lockGL = staticmethod(lockGL)

    def unlockGL() -> "void":
        """unlockGL()"""
        return _soqt.SoQt_unlockGL()

    unlockGL = staticmethod(unlockGL)

    def mainLoop() -> "void":
        """mainLoop()"""
        return _soqt.SoQt_mainLoop()

    mainLoop = staticmethod(mainLoop)
SoQt_swigregister = _soqt.SoQt_swigregister
SoQt_swigregister(SoQt)

def SoQt_init(*args) -> "void":
    """
    init(char const * appname, char const * classname) -> QWidget
    init(char const * appname) -> QWidget
    init(int & argc, char ** argv, char const * appname, char const * classname) -> QWidget
    init(int & argc, char ** argv, char const * appname) -> QWidget
    SoQt_init(QWidget toplevelwidget)
    """
    return _soqt.SoQt_init(*args)

def SoQt_exitMainLoop() -> "void":
    """SoQt_exitMainLoop()"""
    return _soqt.SoQt_exitMainLoop()

def SoQt_done() -> "void":
    """SoQt_done()"""
    return _soqt.SoQt_done()

def SoQt_getTopLevelWidget() -> "QWidget *":
    """SoQt_getTopLevelWidget() -> QWidget"""
    return _soqt.SoQt_getTopLevelWidget()

def SoQt_getShellWidget(w: 'QWidget') -> "QWidget *":
    """SoQt_getShellWidget(QWidget w) -> QWidget"""
    return _soqt.SoQt_getShellWidget(w)

def SoQt_show(widget: 'QWidget') -> "void":
    """SoQt_show(QWidget widget)"""
    return _soqt.SoQt_show(widget)

def SoQt_hide(widget: 'QWidget') -> "void":
    """SoQt_hide(QWidget widget)"""
    return _soqt.SoQt_hide(widget)

def SoQt_setWidgetSize(widget: 'QWidget', size: 'SbVec2s') -> "void":
    """SoQt_setWidgetSize(QWidget widget, SbVec2s size)"""
    return _soqt.SoQt_setWidgetSize(widget, size)

def SoQt_getWidgetSize(widget: 'QWidget') -> "SbVec2s":
    """SoQt_getWidgetSize(QWidget widget) -> SbVec2s"""
    return _soqt.SoQt_getWidgetSize(widget)

def SoQt_createSimpleErrorDialog(widget: 'QWidget', title: 'char const *', string1: 'char const *', string2: 'char const *'=None) -> "void":
    """
    createSimpleErrorDialog(QWidget widget, char const * title, char const * string1, char const * string2=None)
    SoQt_createSimpleErrorDialog(QWidget widget, char const * title, char const * string1)
    """
    return _soqt.SoQt_createSimpleErrorDialog(widget, title, string1, string2)

def SoQt_getVersionInfo(major: 'int *'=None, minor: 'int *'=None, micro: 'int *'=None) -> "void":
    """
    getVersionInfo(int * major=None, int * minor=None, int * micro=None)
    getVersionInfo(int * major=None, int * minor=None)
    getVersionInfo(int * major=None)
    SoQt_getVersionInfo()
    """
    return _soqt.SoQt_getVersionInfo(major, minor, micro)

def SoQt_getVersionString() -> "char const *":
    """SoQt_getVersionString() -> char const *"""
    return _soqt.SoQt_getVersionString()

def SoQt_getVersionToolkitString() -> "char const *":
    """SoQt_getVersionToolkitString() -> char const *"""
    return _soqt.SoQt_getVersionToolkitString()

def SoQt_setFatalErrorHandler(cb: 'SoQt::FatalErrorCB *', userdata: 'void *') -> "SoQt::FatalErrorCB *":
    """SoQt_setFatalErrorHandler(SoQt::FatalErrorCB * cb, void * userdata) -> SoQt::FatalErrorCB *"""
    return _soqt.SoQt_setFatalErrorHandler(cb, userdata)

def SoQt_isDebugLibrary() -> "SbBool":
    """SoQt_isDebugLibrary() -> SbBool"""
    return _soqt.SoQt_isDebugLibrary()

def SoQt_isCompatible(major: 'unsigned int', minor: 'unsigned int') -> "SbBool":
    """SoQt_isCompatible(unsigned int major, unsigned int minor) -> SbBool"""
    return _soqt.SoQt_isCompatible(major, minor)

def SoQt_getABIType() -> "SoQt::ABIType":
    """SoQt_getABIType() -> SoQt::ABIType"""
    return _soqt.SoQt_getABIType()

def SoQt_lockGL() -> "void":
    """SoQt_lockGL()"""
    return _soqt.SoQt_lockGL()

def SoQt_unlockGL() -> "void":
    """SoQt_unlockGL()"""
    return _soqt.SoQt_unlockGL()

def SoQt_mainLoop() -> "void":
    """SoQt_mainLoop()"""
    return _soqt.SoQt_mainLoop()

class SoQtComponent(SoQtObject):
    """Proxy of C++ SoQtComponent class."""

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

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtComponent_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

    def getTypeId(self) -> "SoType":
        """getTypeId(SoQtComponent self) -> SoType"""
        return _soqt.SoQtComponent_getTypeId(self)

    __swig_destroy__ = _soqt.delete_SoQtComponent
    __del__ = lambda self: None

    def show(self) -> "void":
        """show(SoQtComponent self)"""
        return _soqt.SoQtComponent_show(self)


    def hide(self) -> "void":
        """hide(SoQtComponent self)"""
        return _soqt.SoQtComponent_hide(self)


    def setComponentCursor(self, cursor: 'SoQtCursor') -> "void":
        """setComponentCursor(SoQtComponent self, SoQtCursor cursor)"""
        return _soqt.SoQtComponent_setComponentCursor(self, cursor)


    def setWidgetCursor(w: 'QWidget', cursor: 'SoQtCursor') -> "void":
        """setWidgetCursor(QWidget w, SoQtCursor cursor)"""
        return _soqt.SoQtComponent_setWidgetCursor(w, cursor)

    setWidgetCursor = staticmethod(setWidgetCursor)

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


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


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


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


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


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


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


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


    def setSize(self, size: 'SbVec2s') -> "void":
        """setSize(SoQtComponent self, SbVec2s size)"""
        return _soqt.SoQtComponent_setSize(self, size)


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


    def setTitle(self, title: 'char const *const') -> "void":
        """setTitle(SoQtComponent self, char const *const title)"""
        return _soqt.SoQtComponent_setTitle(self, title)


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


    def setIconTitle(self, title: 'char const *const') -> "void":
        """setIconTitle(SoQtComponent self, char const *const title)"""
        return _soqt.SoQtComponent_setIconTitle(self, title)


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


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


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


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


    def getComponent(widget: 'QWidget') -> "SoQtComponent *":
        """getComponent(QWidget widget) -> SoQtComponent"""
        return _soqt.SoQtComponent_getComponent(widget)

    getComponent = staticmethod(getComponent)

    def initClasses() -> "void":
        """initClasses()"""
        return _soqt.SoQtComponent_initClasses()

    initClasses = staticmethod(initClasses)
SoQtComponent_swigregister = _soqt.SoQtComponent_swigregister
SoQtComponent_swigregister(SoQtComponent)

def SoQtComponent_initClass() -> "void":
    """SoQtComponent_initClass()"""
    return _soqt.SoQtComponent_initClass()

def SoQtComponent_getClassTypeId() -> "SoType":
    """SoQtComponent_getClassTypeId() -> SoType"""
    return _soqt.SoQtComponent_getClassTypeId()

def SoQtComponent_setWidgetCursor(w: 'QWidget', cursor: 'SoQtCursor') -> "void":
    """SoQtComponent_setWidgetCursor(QWidget w, SoQtCursor cursor)"""
    return _soqt.SoQtComponent_setWidgetCursor(w, cursor)

def SoQtComponent_getComponent(widget: 'QWidget') -> "SoQtComponent *":
    """SoQtComponent_getComponent(QWidget widget) -> SoQtComponent"""
    return _soqt.SoQtComponent_getComponent(widget)

def SoQtComponent_initClasses() -> "void":
    """SoQtComponent_initClasses()"""
    return _soqt.SoQtComponent_initClasses()

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):
    """Proxy of C++ SoQtGLWidget class."""

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

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtGLWidget_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def setBorder(self, enable: 'SbBool const') -> "void":
        """setBorder(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setBorder(self, enable)


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


    def setDoubleBuffer(self, enable: 'SbBool const') -> "void":
        """setDoubleBuffer(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setDoubleBuffer(self, enable)


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


    def setDrawToFrontBufferEnable(self, enable: 'SbBool const') -> "void":
        """setDrawToFrontBufferEnable(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setDrawToFrontBufferEnable(self, enable)


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


    def setQuadBufferStereo(self, enable: 'SbBool const') -> "void":
        """setQuadBufferStereo(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setQuadBufferStereo(self, enable)


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


    def setAccumulationBuffer(self, enable: 'SbBool const') -> "void":
        """setAccumulationBuffer(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setAccumulationBuffer(self, enable)


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


    def setStencilBuffer(self, enable: 'SbBool const') -> "void":
        """setStencilBuffer(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setStencilBuffer(self, enable)


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


    def setAlphaChannel(self, enable: 'SbBool const') -> "void":
        """setAlphaChannel(SoQtGLWidget self, SbBool const enable)"""
        return _soqt.SoQtGLWidget_setAlphaChannel(self, enable)


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


    def setOverlayRender(self, onoff: 'SbBool const') -> "void":
        """setOverlayRender(SoQtGLWidget self, SbBool const onoff)"""
        return _soqt.SoQtGLWidget_setOverlayRender(self, onoff)


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


    def setSampleBuffers(self, numsamples: 'int const') -> "void":
        """setSampleBuffers(SoQtGLWidget self, int const numsamples)"""
        return _soqt.SoQtGLWidget_setSampleBuffers(self, numsamples)


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


    def setStealFocus(self, enable: 'SbBool') -> "void":
        """setStealFocus(SoQtGLWidget self, SbBool enable)"""
        return _soqt.SoQtGLWidget_setStealFocus(self, enable)


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


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


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


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


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


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


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


    def getPointSizeLimits(self, range: 'SbVec2f', granularity: 'float &') -> "void":
        """getPointSizeLimits(SoQtGLWidget self, SbVec2f range, float & granularity)"""
        return _soqt.SoQtGLWidget_getPointSizeLimits(self, range, granularity)


    def getLineWidthLimits(self, range: 'SbVec2f', granularity: 'float &') -> "void":
        """getLineWidthLimits(SoQtGLWidget self, SbVec2f range, float & granularity)"""
        return _soqt.SoQtGLWidget_getLineWidthLimits(self, range, granularity)

SoQtGLWidget_swigregister = _soqt.SoQtGLWidget_swigregister
SoQtGLWidget_swigregister(SoQtGLWidget)

def SoQtGLWidget_initClass() -> "void":
    """SoQtGLWidget_initClass()"""
    return _soqt.SoQtGLWidget_initClass()

def SoQtGLWidget_getClassTypeId() -> "SoType":
    """SoQtGLWidget_getClassTypeId() -> SoType"""
    return _soqt.SoQtGLWidget_getClassTypeId()

class SoQtRenderArea(SoQtGLWidget):
    """Proxy of C++ SoQtRenderArea class."""

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtRenderArea_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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

    createInstance = staticmethod(createInstance)

    def __init__(self, parent: 'QWidget'=None, name: 'char const *'=None, embed: 'SbBool'=1, mouseInput: 'SbBool'=1, keyboardInput: 'SbBool'=1):
        """
        __init__(SoQtRenderArea self, QWidget parent=None, char const * name=None, SbBool embed=1, SbBool mouseInput=1, SbBool keyboardInput=1) -> SoQtRenderArea
        __init__(SoQtRenderArea self, QWidget parent=None, char const * name=None, SbBool embed=1, SbBool mouseInput=1) -> SoQtRenderArea
        __init__(SoQtRenderArea self, QWidget parent=None, char const * name=None, SbBool embed=1) -> SoQtRenderArea
        __init__(SoQtRenderArea self, QWidget parent=None, char const * name=None) -> SoQtRenderArea
        __init__(SoQtRenderArea self, QWidget parent=None) -> SoQtRenderArea
        __init__(SoQtRenderArea self) -> SoQtRenderArea
        """
        this = _soqt.new_SoQtRenderArea(parent, name, embed, mouseInput, keyboardInput)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtRenderArea
    __del__ = lambda self: None

    def setSceneGraph(self, scene: 'SoNode') -> "void":
        """setSceneGraph(SoQtRenderArea self, SoNode scene)"""
        return _soqt.SoQtRenderArea_setSceneGraph(self, scene)


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


    def setOverlaySceneGraph(self, scene: 'SoNode') -> "void":
        """setOverlaySceneGraph(SoQtRenderArea self, SoNode scene)"""
        return _soqt.SoQtRenderArea_setOverlaySceneGraph(self, scene)


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


    def setBackgroundColor(self, color: 'SbColor') -> "void":
        """setBackgroundColor(SoQtRenderArea self, SbColor color)"""
        return _soqt.SoQtRenderArea_setBackgroundColor(self, color)


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


    def setBackgroundIndex(self, idx: 'int') -> "void":
        """setBackgroundIndex(SoQtRenderArea self, int idx)"""
        return _soqt.SoQtRenderArea_setBackgroundIndex(self, idx)


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


    def setOverlayBackgroundIndex(self, idx: 'int') -> "void":
        """setOverlayBackgroundIndex(SoQtRenderArea self, int idx)"""
        return _soqt.SoQtRenderArea_setOverlayBackgroundIndex(self, idx)


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


    def setColorMap(self, start: 'int', num: 'int', colors: 'SbColor') -> "void":
        """setColorMap(SoQtRenderArea self, int start, int num, SbColor colors)"""
        return _soqt.SoQtRenderArea_setColorMap(self, start, num, colors)


    def setOverlayColorMap(self, start: 'int', num: 'int', colors: 'SbColor') -> "void":
        """setOverlayColorMap(SoQtRenderArea self, int start, int num, SbColor colors)"""
        return _soqt.SoQtRenderArea_setOverlayColorMap(self, start, num, colors)


    def setViewportRegion(self, newRegion: 'SbViewportRegion') -> "void":
        """setViewportRegion(SoQtRenderArea self, SbViewportRegion newRegion)"""
        return _soqt.SoQtRenderArea_setViewportRegion(self, newRegion)


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


    def setTransparencyType(self, type: 'SoGLRenderAction::TransparencyType') -> "void":
        """setTransparencyType(SoQtRenderArea self, SoGLRenderAction::TransparencyType type)"""
        return _soqt.SoQtRenderArea_setTransparencyType(self, type)


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


    def setAntialiasing(self, smoothing: 'SbBool', numPasses: 'int') -> "void":
        """setAntialiasing(SoQtRenderArea self, SbBool smoothing, int numPasses)"""
        return _soqt.SoQtRenderArea_setAntialiasing(self, smoothing, numPasses)


    def getAntialiasing(self, smoothing: 'SbBool &', numPasses: 'int &') -> "void":
        """getAntialiasing(SoQtRenderArea self, SbBool & smoothing, int & numPasses)"""
        return _soqt.SoQtRenderArea_getAntialiasing(self, smoothing, numPasses)


    def setClearBeforeRender(self, enable: 'SbBool', zbEnable: 'SbBool'=1) -> "void":
        """
        setClearBeforeRender(SoQtRenderArea self, SbBool enable, SbBool zbEnable=1)
        setClearBeforeRender(SoQtRenderArea self, SbBool enable)
        """
        return _soqt.SoQtRenderArea_setClearBeforeRender(self, enable, zbEnable)


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


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


    def setClearBeforeOverlayRender(self, enable: 'SbBool') -> "void":
        """setClearBeforeOverlayRender(SoQtRenderArea self, SbBool enable)"""
        return _soqt.SoQtRenderArea_setClearBeforeOverlayRender(self, enable)


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


    def setAutoRedraw(self, enable: 'SbBool') -> "void":
        """setAutoRedraw(SoQtRenderArea self, SbBool enable)"""
        return _soqt.SoQtRenderArea_setAutoRedraw(self, enable)


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


    def setRedrawPriority(self, priority: 'uint32_t') -> "void":
        """setRedrawPriority(SoQtRenderArea self, uint32_t priority)"""
        return _soqt.SoQtRenderArea_setRedrawPriority(self, priority)


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


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

    getDefaultRedrawPriority = staticmethod(getDefaultRedrawPriority)

    def render(self) -> "void":
        """render(SoQtRenderArea self)"""
        return _soqt.SoQtRenderArea_render(self)


    def renderOverlay(self) -> "void":
        """renderOverlay(SoQtRenderArea self)"""
        return _soqt.SoQtRenderArea_renderOverlay(self)


    def scheduleRedraw(self) -> "void":
        """scheduleRedraw(SoQtRenderArea self)"""
        return _soqt.SoQtRenderArea_scheduleRedraw(self)


    def scheduleOverlayRedraw(self) -> "void":
        """scheduleOverlayRedraw(SoQtRenderArea self)"""
        return _soqt.SoQtRenderArea_scheduleOverlayRedraw(self)


    def redrawOnSelectionChange(self, selection: 'SoSelection') -> "void":
        """redrawOnSelectionChange(SoQtRenderArea self, SoSelection selection)"""
        return _soqt.SoQtRenderArea_redrawOnSelectionChange(self, selection)


    def redrawOverlayOnSelectionChange(self, selection: 'SoSelection') -> "void":
        """redrawOverlayOnSelectionChange(SoQtRenderArea self, SoSelection selection)"""
        return _soqt.SoQtRenderArea_redrawOverlayOnSelectionChange(self, selection)


    def setSceneManager(self, manager: 'SoSceneManager') -> "void":
        """setSceneManager(SoQtRenderArea self, SoSceneManager manager)"""
        return _soqt.SoQtRenderArea_setSceneManager(self, manager)


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


    def setOverlaySceneManager(self, manager: 'SoSceneManager') -> "void":
        """setOverlaySceneManager(SoQtRenderArea self, SoSceneManager manager)"""
        return _soqt.SoQtRenderArea_setOverlaySceneManager(self, manager)


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


    def setGLRenderAction(self, action: 'SoGLRenderAction') -> "void":
        """setGLRenderAction(SoQtRenderArea self, SoGLRenderAction action)"""
        return _soqt.SoQtRenderArea_setGLRenderAction(self, action)


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


    def setOverlayGLRenderAction(self, action: 'SoGLRenderAction') -> "void":
        """setOverlayGLRenderAction(SoQtRenderArea self, SoGLRenderAction action)"""
        return _soqt.SoQtRenderArea_setOverlayGLRenderAction(self, action)


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


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


    def registerDevice(self, device: 'SoQtDevice') -> "void":
        """registerDevice(SoQtRenderArea self, SoQtDevice device)"""
        return _soqt.SoQtRenderArea_registerDevice(self, device)


    def unregisterDevice(self, device: 'SoQtDevice') -> "void":
        """unregisterDevice(SoQtRenderArea self, SoQtDevice device)"""
        return _soqt.SoQtRenderArea_unregisterDevice(self, device)


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

SoQtRenderArea_swigregister = _soqt.SoQtRenderArea_swigregister
SoQtRenderArea_swigregister(SoQtRenderArea)

def SoQtRenderArea_initClass() -> "void":
    """SoQtRenderArea_initClass()"""
    return _soqt.SoQtRenderArea_initClass()

def SoQtRenderArea_getClassTypeId() -> "SoType":
    """SoQtRenderArea_getClassTypeId() -> SoType"""
    return _soqt.SoQtRenderArea_getClassTypeId()

def SoQtRenderArea_createInstance() -> "void *":
    """SoQtRenderArea_createInstance() -> void *"""
    return _soqt.SoQtRenderArea_createInstance()

def SoQtRenderArea_getDefaultRedrawPriority() -> "uint32_t":
    """SoQtRenderArea_getDefaultRedrawPriority() -> uint32_t"""
    return _soqt.SoQtRenderArea_getDefaultRedrawPriority()

class SoQtViewer(SoQtRenderArea):
    """Proxy of C++ SoQtViewer class."""

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

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

    def getTypeId(self) -> "SoType":
        """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: 'SoCamera') -> "void":
        """setCamera(SoQtViewer self, SoCamera camera)"""
        return _soqt.SoQtViewer_setCamera(self, camera)


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


    def setCameraType(self, type: 'SoType') -> "void":
        """setCameraType(SoQtViewer self, SoType type)"""
        return _soqt.SoQtViewer_setCameraType(self, type)


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


    def toggleCameraType(self) -> "void":
        """toggleCameraType(SoQtViewer self)"""
        return _soqt.SoQtViewer_toggleCameraType(self)


    def viewAll(self) -> "void":
        """viewAll(SoQtViewer self)"""
        return _soqt.SoQtViewer_viewAll(self)


    def saveHomePosition(self) -> "void":
        """saveHomePosition(SoQtViewer self)"""
        return _soqt.SoQtViewer_saveHomePosition(self)


    def resetToHomePosition(self) -> "void":
        """resetToHomePosition(SoQtViewer self)"""
        return _soqt.SoQtViewer_resetToHomePosition(self)


    def setHeadlight(self, enable: 'SbBool') -> "void":
        """setHeadlight(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setHeadlight(self, enable)


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


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


    def setDrawStyle(self, type: 'SoQtViewer::DrawType', style: 'SoQtViewer::DrawStyle') -> "void":
        """setDrawStyle(SoQtViewer self, SoQtViewer::DrawType type, SoQtViewer::DrawStyle style)"""
        return _soqt.SoQtViewer_setDrawStyle(self, type, style)


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


    def setBufferingType(self, type: 'SoQtViewer::BufferType') -> "void":
        """setBufferingType(SoQtViewer self, SoQtViewer::BufferType type)"""
        return _soqt.SoQtViewer_setBufferingType(self, type)


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


    def setViewing(self, enable: 'SbBool') -> "void":
        """setViewing(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setViewing(self, enable)


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


    def setCursorEnabled(self, enable: 'SbBool') -> "void":
        """setCursorEnabled(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setCursorEnabled(self, enable)


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


    def setAutoClipping(self, enable: 'SbBool') -> "void":
        """setAutoClipping(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setAutoClipping(self, enable)


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


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


    def setStereoViewing(self, enable: 'SbBool') -> "void":
        """setStereoViewing(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setStereoViewing(self, enable)


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


    def setStereoOffset(self, dist: 'float const') -> "void":
        """setStereoOffset(SoQtViewer self, float const dist)"""
        return _soqt.SoQtViewer_setStereoOffset(self, dist)


    def getStereoOffset(self) -> "float":
        """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: 'SoQtViewer::StereoType') -> "SbBool":
        """setStereoType(SoQtViewer self, SoQtViewer::StereoType s) -> SbBool"""
        return _soqt.SoQtViewer_setStereoType(self, s)


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


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


    def getAnaglyphStereoColorMasks(self, left: 'SbBool [3]', right: 'SbBool [3]') -> "void":
        """getAnaglyphStereoColorMasks(SoQtViewer self, SbBool [3] left, SbBool [3] right)"""
        return _soqt.SoQtViewer_getAnaglyphStereoColorMasks(self, left, right)


    def setDetailSeek(self, enable: 'SbBool const') -> "void":
        """setDetailSeek(SoQtViewer self, SbBool const enable)"""
        return _soqt.SoQtViewer_setDetailSeek(self, enable)


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


    def setSeekTime(self, seconds: 'float const') -> "void":
        """setSeekTime(SoQtViewer self, float const seconds)"""
        return _soqt.SoQtViewer_setSeekTime(self, seconds)


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


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


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


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


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


    def setWireframeOverlayColor(self, color: 'SbColor') -> "void":
        """setWireframeOverlayColor(SoQtViewer self, SbColor color)"""
        return _soqt.SoQtViewer_setWireframeOverlayColor(self, color)


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


    def setDoubleBuffer(self, enable: 'SbBool const') -> "void":
        """setDoubleBuffer(SoQtViewer self, SbBool const enable)"""
        return _soqt.SoQtViewer_setDoubleBuffer(self, enable)


    def setSceneGraph(self, root: 'SoNode') -> "void":
        """setSceneGraph(SoQtViewer self, SoNode root)"""
        return _soqt.SoQtViewer_setSceneGraph(self, root)


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

SoQtViewer_swigregister = _soqt.SoQtViewer_swigregister
SoQtViewer_swigregister(SoQtViewer)

def SoQtViewer_initClass() -> "void":
    """SoQtViewer_initClass()"""
    return _soqt.SoQtViewer_initClass()

def SoQtViewer_getClassTypeId() -> "SoType":
    """SoQtViewer_getClassTypeId() -> SoType"""
    return _soqt.SoQtViewer_getClassTypeId()

class SoQtFullViewer(SoQtViewer):
    """Proxy of C++ SoQtFullViewer class."""

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

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtFullViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

    def getTypeId(self) -> "SoType":
        """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: 'SbBool const') -> "void":
        """setDecoration(SoQtFullViewer self, SbBool const on)"""
        return _soqt.SoQtFullViewer_setDecoration(self, on)


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


    def setPopupMenuEnabled(self, on: 'SbBool const') -> "void":
        """setPopupMenuEnabled(SoQtFullViewer self, SbBool const on)"""
        return _soqt.SoQtFullViewer_setPopupMenuEnabled(self, on)


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


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


    def addAppPushButton(self, newButton: 'QWidget') -> "void":
        """addAppPushButton(SoQtFullViewer self, QWidget newButton)"""
        return _soqt.SoQtFullViewer_addAppPushButton(self, newButton)


    def insertAppPushButton(self, newButton: 'QWidget', index: 'int') -> "void":
        """insertAppPushButton(SoQtFullViewer self, QWidget newButton, int index)"""
        return _soqt.SoQtFullViewer_insertAppPushButton(self, newButton, index)


    def removeAppPushButton(self, oldButton: 'QWidget') -> "void":
        """removeAppPushButton(SoQtFullViewer self, QWidget oldButton)"""
        return _soqt.SoQtFullViewer_removeAppPushButton(self, oldButton)


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


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


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


    def setViewing(self, on: 'SbBool') -> "void":
        """setViewing(SoQtFullViewer self, SbBool on)"""
        return _soqt.SoQtFullViewer_setViewing(self, on)


    def setComponentCursor(self, cursor: 'SoQtCursor') -> "void":
        """setComponentCursor(SoQtFullViewer self, SoQtCursor cursor)"""
        return _soqt.SoQtFullViewer_setComponentCursor(self, cursor)

SoQtFullViewer_swigregister = _soqt.SoQtFullViewer_swigregister
SoQtFullViewer_swigregister(SoQtFullViewer)

def SoQtFullViewer_initClass() -> "void":
    """SoQtFullViewer_initClass()"""
    return _soqt.SoQtFullViewer_initClass()

def SoQtFullViewer_getClassTypeId() -> "SoType":
    """SoQtFullViewer_getClassTypeId() -> SoType"""
    return _soqt.SoQtFullViewer_getClassTypeId()

class SoQtPlaneViewer(SoQtFullViewer):
    """Proxy of C++ SoQtPlaneViewer class."""

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtPlaneViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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

    createInstance = staticmethod(createInstance)

    def __init__(self, *args):
        """
        __init__(SoQtPlaneViewer self, QWidget parent=None, char const *const name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag, SoQtViewer::Type type) -> SoQtPlaneViewer
        __init__(SoQtPlaneViewer self, QWidget parent=None, char const *const name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag) -> SoQtPlaneViewer
        __init__(SoQtPlaneViewer self, QWidget parent=None, char const *const name=None, SbBool embed=1) -> SoQtPlaneViewer
        __init__(SoQtPlaneViewer self, QWidget parent=None, char const *const name=None) -> SoQtPlaneViewer
        __init__(SoQtPlaneViewer self, QWidget parent=None) -> SoQtPlaneViewer
        __init__(SoQtPlaneViewer self) -> SoQtPlaneViewer
        """
        this = _soqt.new_SoQtPlaneViewer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtPlaneViewer
    __del__ = lambda self: None

    def setViewing(self, enable: 'SbBool') -> "void":
        """setViewing(SoQtPlaneViewer self, SbBool enable)"""
        return _soqt.SoQtPlaneViewer_setViewing(self, enable)


    def setCamera(self, camera: 'SoCamera') -> "void":
        """setCamera(SoQtPlaneViewer self, SoCamera camera)"""
        return _soqt.SoQtPlaneViewer_setCamera(self, camera)


    def setCursorEnabled(self, enable: 'SbBool') -> "void":
        """setCursorEnabled(SoQtPlaneViewer self, SbBool enable)"""
        return _soqt.SoQtPlaneViewer_setCursorEnabled(self, enable)

SoQtPlaneViewer_swigregister = _soqt.SoQtPlaneViewer_swigregister
SoQtPlaneViewer_swigregister(SoQtPlaneViewer)

def SoQtPlaneViewer_initClass() -> "void":
    """SoQtPlaneViewer_initClass()"""
    return _soqt.SoQtPlaneViewer_initClass()

def SoQtPlaneViewer_getClassTypeId() -> "SoType":
    """SoQtPlaneViewer_getClassTypeId() -> SoType"""
    return _soqt.SoQtPlaneViewer_getClassTypeId()

def SoQtPlaneViewer_createInstance() -> "void *":
    """SoQtPlaneViewer_createInstance() -> void *"""
    return _soqt.SoQtPlaneViewer_createInstance()

class SoQtExaminerViewer(SoQtFullViewer):
    """Proxy of C++ SoQtExaminerViewer class."""

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtExaminerViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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

    createInstance = staticmethod(createInstance)

    def __init__(self, *args):
        """
        __init__(SoQtExaminerViewer self, QWidget parent=None, char const * name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag, SoQtViewer::Type type) -> SoQtExaminerViewer
        __init__(SoQtExaminerViewer self, QWidget parent=None, char const * name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag) -> SoQtExaminerViewer
        __init__(SoQtExaminerViewer self, QWidget parent=None, char const * name=None, SbBool embed=1) -> SoQtExaminerViewer
        __init__(SoQtExaminerViewer self, QWidget parent=None, char const * name=None) -> SoQtExaminerViewer
        __init__(SoQtExaminerViewer self, QWidget parent=None) -> SoQtExaminerViewer
        __init__(SoQtExaminerViewer self) -> SoQtExaminerViewer
        """
        this = _soqt.new_SoQtExaminerViewer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtExaminerViewer
    __del__ = lambda self: None

    def setAnimationEnabled(self, enable: 'SbBool const') -> "void":
        """setAnimationEnabled(SoQtExaminerViewer self, SbBool const enable)"""
        return _soqt.SoQtExaminerViewer_setAnimationEnabled(self, enable)


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


    def stopAnimating(self) -> "void":
        """stopAnimating(SoQtExaminerViewer self)"""
        return _soqt.SoQtExaminerViewer_stopAnimating(self)


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


    def setFeedbackVisibility(self, enable: 'SbBool const') -> "void":
        """setFeedbackVisibility(SoQtExaminerViewer self, SbBool const enable)"""
        return _soqt.SoQtExaminerViewer_setFeedbackVisibility(self, enable)


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


    def setFeedbackSize(self, size: 'int const') -> "void":
        """setFeedbackSize(SoQtExaminerViewer self, int const size)"""
        return _soqt.SoQtExaminerViewer_setFeedbackSize(self, size)


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


    def setViewing(self, enable: 'SbBool') -> "void":
        """setViewing(SoQtExaminerViewer self, SbBool enable)"""
        return _soqt.SoQtExaminerViewer_setViewing(self, enable)


    def setCamera(self, camera: 'SoCamera') -> "void":
        """setCamera(SoQtExaminerViewer self, SoCamera camera)"""
        return _soqt.SoQtExaminerViewer_setCamera(self, camera)


    def setCursorEnabled(self, enable: 'SbBool') -> "void":
        """setCursorEnabled(SoQtExaminerViewer self, SbBool enable)"""
        return _soqt.SoQtExaminerViewer_setCursorEnabled(self, enable)

SoQtExaminerViewer_swigregister = _soqt.SoQtExaminerViewer_swigregister
SoQtExaminerViewer_swigregister(SoQtExaminerViewer)

def SoQtExaminerViewer_initClass() -> "void":
    """SoQtExaminerViewer_initClass()"""
    return _soqt.SoQtExaminerViewer_initClass()

def SoQtExaminerViewer_getClassTypeId() -> "SoType":
    """SoQtExaminerViewer_getClassTypeId() -> SoType"""
    return _soqt.SoQtExaminerViewer_getClassTypeId()

def SoQtExaminerViewer_createInstance() -> "void *":
    """SoQtExaminerViewer_createInstance() -> void *"""
    return _soqt.SoQtExaminerViewer_createInstance()

class SoQtConstrainedViewer(SoQtFullViewer):
    """Proxy of C++ SoQtConstrainedViewer class."""

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

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtConstrainedViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def setUpDirection(self, dir: 'SbVec3f') -> "void":
        """setUpDirection(SoQtConstrainedViewer self, SbVec3f dir)"""
        return _soqt.SoQtConstrainedViewer_setUpDirection(self, dir)


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


    def setCamera(self, newcam: 'SoCamera') -> "void":
        """setCamera(SoQtConstrainedViewer self, SoCamera newcam)"""
        return _soqt.SoQtConstrainedViewer_setCamera(self, newcam)


    def saveHomePosition(self) -> "void":
        """saveHomePosition(SoQtConstrainedViewer self)"""
        return _soqt.SoQtConstrainedViewer_saveHomePosition(self)


    def resetToHomePosition(self) -> "void":
        """resetToHomePosition(SoQtConstrainedViewer self)"""
        return _soqt.SoQtConstrainedViewer_resetToHomePosition(self)

SoQtConstrainedViewer_swigregister = _soqt.SoQtConstrainedViewer_swigregister
SoQtConstrainedViewer_swigregister(SoQtConstrainedViewer)

def SoQtConstrainedViewer_initClass() -> "void":
    """SoQtConstrainedViewer_initClass()"""
    return _soqt.SoQtConstrainedViewer_initClass()

def SoQtConstrainedViewer_getClassTypeId() -> "SoType":
    """SoQtConstrainedViewer_getClassTypeId() -> SoType"""
    return _soqt.SoQtConstrainedViewer_getClassTypeId()

class SoQtFlyViewer(SoQtConstrainedViewer):
    """Proxy of C++ SoQtFlyViewer class."""

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtFlyViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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

    createInstance = staticmethod(createInstance)

    def __init__(self, *args):
        """
        __init__(SoQtFlyViewer self, QWidget parent=None, char const * name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag, SoQtViewer::Type type) -> SoQtFlyViewer
        __init__(SoQtFlyViewer self, QWidget parent=None, char const * name=None, SbBool embed=1, SoQtFullViewer::BuildFlag flag) -> SoQtFlyViewer
        __init__(SoQtFlyViewer self, QWidget parent=None, char const * name=None, SbBool embed=1) -> SoQtFlyViewer
        __init__(SoQtFlyViewer self, QWidget parent=None, char const * name=None) -> SoQtFlyViewer
        __init__(SoQtFlyViewer self, QWidget parent=None) -> SoQtFlyViewer
        __init__(SoQtFlyViewer self) -> SoQtFlyViewer
        """
        this = _soqt.new_SoQtFlyViewer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtFlyViewer
    __del__ = lambda self: None

    def setViewing(self, enable: 'SbBool') -> "void":
        """setViewing(SoQtFlyViewer self, SbBool enable)"""
        return _soqt.SoQtFlyViewer_setViewing(self, enable)


    def viewAll(self) -> "void":
        """viewAll(SoQtFlyViewer self)"""
        return _soqt.SoQtFlyViewer_viewAll(self)


    def resetToHomePosition(self) -> "void":
        """resetToHomePosition(SoQtFlyViewer self)"""
        return _soqt.SoQtFlyViewer_resetToHomePosition(self)


    def setCamera(self, camera: 'SoCamera') -> "void":
        """setCamera(SoQtFlyViewer self, SoCamera camera)"""
        return _soqt.SoQtFlyViewer_setCamera(self, camera)


    def setCursorEnabled(self, enable: 'SbBool') -> "void":
        """setCursorEnabled(SoQtFlyViewer self, SbBool enable)"""
        return _soqt.SoQtFlyViewer_setCursorEnabled(self, enable)


    def setCameraType(self, type: 'SoType') -> "void":
        """setCameraType(SoQtFlyViewer self, SoType type)"""
        return _soqt.SoQtFlyViewer_setCameraType(self, type)

SoQtFlyViewer_swigregister = _soqt.SoQtFlyViewer_swigregister
SoQtFlyViewer_swigregister(SoQtFlyViewer)

def SoQtFlyViewer_initClass() -> "void":
    """SoQtFlyViewer_initClass()"""
    return _soqt.SoQtFlyViewer_initClass()

def SoQtFlyViewer_getClassTypeId() -> "SoType":
    """SoQtFlyViewer_getClassTypeId() -> SoType"""
    return _soqt.SoQtFlyViewer_getClassTypeId()

def SoQtFlyViewer_createInstance() -> "void *":
    """SoQtFlyViewer_createInstance() -> void *"""
    return _soqt.SoQtFlyViewer_createInstance()

class SoQtPopupMenu(object):
    """Proxy of C++ SoQtPopupMenu class."""

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

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

    def createInstance() -> "SoQtPopupMenu *":
        """createInstance() -> SoQtPopupMenu"""
        return _soqt.SoQtPopupMenu_createInstance()

    createInstance = staticmethod(createInstance)
    __swig_destroy__ = _soqt.delete_SoQtPopupMenu
    __del__ = lambda self: None

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


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


    def setMenuTitle(self, id: 'int', title: 'char const *') -> "void":
        """setMenuTitle(SoQtPopupMenu self, int id, char const * title)"""
        return _soqt.SoQtPopupMenu_setMenuTitle(self, id, title)


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


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


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


    def setMenuItemTitle(self, itemid: 'int', title: 'char const *') -> "void":
        """setMenuItemTitle(SoQtPopupMenu self, int itemid, char const * title)"""
        return _soqt.SoQtPopupMenu_setMenuItemTitle(self, itemid, title)


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


    def setMenuItemEnabled(self, itemid: 'int', enabled: 'SbBool') -> "void":
        """setMenuItemEnabled(SoQtPopupMenu self, int itemid, SbBool enabled)"""
        return _soqt.SoQtPopupMenu_setMenuItemEnabled(self, itemid, enabled)


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


    def setMenuItemMarked(self, itemid: 'int', marked: 'SbBool') -> "void":
        """setMenuItemMarked(SoQtPopupMenu self, int itemid, SbBool marked)"""
        return _soqt.SoQtPopupMenu_setMenuItemMarked(self, itemid, marked)


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


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


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


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


    def removeMenu(self, menuid: 'int') -> "void":
        """removeMenu(SoQtPopupMenu self, int menuid)"""
        return _soqt.SoQtPopupMenu_removeMenu(self, menuid)


    def removeMenuItem(self, itemid: 'int') -> "void":
        """removeMenuItem(SoQtPopupMenu self, int itemid)"""
        return _soqt.SoQtPopupMenu_removeMenuItem(self, itemid)


    def popUp(self, inside: 'QWidget', x: 'int', y: 'int') -> "void":
        """popUp(SoQtPopupMenu self, QWidget inside, int x, int y)"""
        return _soqt.SoQtPopupMenu_popUp(self, inside, x, y)


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


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


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


    def addRadioGroupItem(self, groupid: 'int', itemid: 'int') -> "void":
        """addRadioGroupItem(SoQtPopupMenu self, int groupid, int itemid)"""
        return _soqt.SoQtPopupMenu_addRadioGroupItem(self, groupid, itemid)


    def removeRadioGroupItem(self, itemid: 'int') -> "void":
        """removeRadioGroupItem(SoQtPopupMenu self, int itemid)"""
        return _soqt.SoQtPopupMenu_removeRadioGroupItem(self, itemid)


    def setRadioGroupMarkedItem(self, itemid: 'int') -> "void":
        """setRadioGroupMarkedItem(SoQtPopupMenu self, int itemid)"""
        return _soqt.SoQtPopupMenu_setRadioGroupMarkedItem(self, itemid)


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


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


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

SoQtPopupMenu_swigregister = _soqt.SoQtPopupMenu_swigregister
SoQtPopupMenu_swigregister(SoQtPopupMenu)

def SoQtPopupMenu_createInstance() -> "SoQtPopupMenu *":
    """SoQtPopupMenu_createInstance() -> SoQtPopupMenu"""
    return _soqt.SoQtPopupMenu_createInstance()

class SoQtCursor(object):
    """Proxy of C++ SoQtCursor class."""

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

    def initClass() -> "void":
        """initClass()"""
        return _soqt.SoQtCursor_initClass()

    initClass = staticmethod(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):
        """
        __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
        """
        this = _soqt.new_SoQtCursor(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtCursor
    __del__ = lambda self: None

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


    def setShape(self, shape: 'SoQtCursor::Shape const') -> "void":
        """setShape(SoQtCursor self, SoQtCursor::Shape const shape)"""
        return _soqt.SoQtCursor_setShape(self, shape)


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


    def getZoomCursor() -> "SoQtCursor const &":
        """getZoomCursor() -> SoQtCursor"""
        return _soqt.SoQtCursor_getZoomCursor()

    getZoomCursor = staticmethod(getZoomCursor)

    def getPanCursor() -> "SoQtCursor const &":
        """getPanCursor() -> SoQtCursor"""
        return _soqt.SoQtCursor_getPanCursor()

    getPanCursor = staticmethod(getPanCursor)

    def getRotateCursor() -> "SoQtCursor const &":
        """getRotateCursor() -> SoQtCursor"""
        return _soqt.SoQtCursor_getRotateCursor()

    getRotateCursor = staticmethod(getRotateCursor)

    def getBlankCursor() -> "SoQtCursor const &":
        """getBlankCursor() -> SoQtCursor"""
        return _soqt.SoQtCursor_getBlankCursor()

    getBlankCursor = staticmethod(getBlankCursor)
SoQtCursor_swigregister = _soqt.SoQtCursor_swigregister
SoQtCursor_swigregister(SoQtCursor)

def SoQtCursor_initClass() -> "void":
    """SoQtCursor_initClass()"""
    return _soqt.SoQtCursor_initClass()

def SoQtCursor_getZoomCursor() -> "SoQtCursor const &":
    """SoQtCursor_getZoomCursor() -> SoQtCursor"""
    return _soqt.SoQtCursor_getZoomCursor()

def SoQtCursor_getPanCursor() -> "SoQtCursor const &":
    """SoQtCursor_getPanCursor() -> SoQtCursor"""
    return _soqt.SoQtCursor_getPanCursor()

def SoQtCursor_getRotateCursor() -> "SoQtCursor const &":
    """SoQtCursor_getRotateCursor() -> SoQtCursor"""
    return _soqt.SoQtCursor_getRotateCursor()

def SoQtCursor_getBlankCursor() -> "SoQtCursor const &":
    """SoQtCursor_getBlankCursor() -> SoQtCursor"""
    return _soqt.SoQtCursor_getBlankCursor()



