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




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


from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_soqt', [dirname(__file__)])
        except ImportError:
            import _soqt
            return _soqt
        if fp is not None:
            try:
                _mod = imp.load_module('_soqt', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _soqt = swig_import_helper()
    del swig_import_helper
else:
    import _soqt
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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


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


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

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


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

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



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


class charp(object):
    thisown = _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:
            self.this = this
    __swig_destroy__ = _soqt.delete_charp
    __del__ = lambda self: None

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

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

    def cast(self):
        return _soqt.charp_cast(self)
    frompointer = staticmethod(_soqt.charp_frompointer)
charp_swigregister = _soqt.charp_swigregister
charp_swigregister(charp)
cast = _soqt.cast

def charp_frompointer(t):
    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:
            self.this = this
    __swig_destroy__ = _soqt.delete_intp
    __del__ = lambda self: None

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

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

    def cast(self):
        return _soqt.intp_cast(self)
    frompointer = staticmethod(_soqt.intp_frompointer)
intp_swigregister = _soqt.intp_swigregister
intp_swigregister(intp)

def intp_frompointer(t):
    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:
            self.this = this
    __swig_destroy__ = _soqt.delete_longp
    __del__ = lambda self: None

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

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

    def cast(self):
        return _soqt.longp_cast(self)
    frompointer = staticmethod(_soqt.longp_frompointer)
longp_swigregister = _soqt.longp_swigregister
longp_swigregister(longp)

def longp_frompointer(t):
    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:
            self.this = this
    __swig_destroy__ = _soqt.delete_floatp
    __del__ = lambda self: None

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

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

    def cast(self):
        return _soqt.floatp_cast(self)
    frompointer = staticmethod(_soqt.floatp_frompointer)
floatp_swigregister = _soqt.floatp_swigregister
floatp_swigregister(floatp)

def floatp_frompointer(t):
    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:
            self.this = this
    __swig_destroy__ = _soqt.delete_doublep
    __del__ = lambda self: None

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

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

    def cast(self):
        return _soqt.doublep_cast(self)
    frompointer = staticmethod(_soqt.doublep_frompointer)
doublep_swigregister = _soqt.doublep_swigregister
doublep_swigregister(doublep)

def doublep_frompointer(t):
    return _soqt.doublep_frompointer(t)
doublep_frompointer = _soqt.doublep_frompointer


_soqt.FALSE_swigconstant(_soqt)
FALSE = _soqt.FALSE

_soqt.TRUE_swigconstant(_soqt)
TRUE = _soqt.TRUE

_soqt.HAVE_INTTYPES_H_swigconstant(_soqt)
HAVE_INTTYPES_H = _soqt.HAVE_INTTYPES_H

_soqt.HAVE_STDINT_H_swigconstant(_soqt)
HAVE_STDINT_H = _soqt.HAVE_STDINT_H

_soqt.HAVE_SYS_TYPES_H_swigconstant(_soqt)
HAVE_SYS_TYPES_H = _soqt.HAVE_SYS_TYPES_H

_soqt.HAVE_STDDEF_H_swigconstant(_soqt)
HAVE_STDDEF_H = _soqt.HAVE_STDDEF_H

_soqt.HAVE_INT8_T_swigconstant(_soqt)
HAVE_INT8_T = _soqt.HAVE_INT8_T

_soqt.HAVE_UINT8_T_swigconstant(_soqt)
HAVE_UINT8_T = _soqt.HAVE_UINT8_T

_soqt.HAVE_INT16_T_swigconstant(_soqt)
HAVE_INT16_T = _soqt.HAVE_INT16_T

_soqt.HAVE_UINT16_T_swigconstant(_soqt)
HAVE_UINT16_T = _soqt.HAVE_UINT16_T

_soqt.HAVE_INT32_T_swigconstant(_soqt)
HAVE_INT32_T = _soqt.HAVE_INT32_T

_soqt.HAVE_UINT32_T_swigconstant(_soqt)
HAVE_UINT32_T = _soqt.HAVE_UINT32_T

_soqt.HAVE_INT64_T_swigconstant(_soqt)
HAVE_INT64_T = _soqt.HAVE_INT64_T

_soqt.HAVE_UINT64_T_swigconstant(_soqt)
HAVE_UINT64_T = _soqt.HAVE_UINT64_T

_soqt.HAVE_INTPTR_T_swigconstant(_soqt)
HAVE_INTPTR_T = _soqt.HAVE_INTPTR_T

_soqt.HAVE_UINTPTR_T_swigconstant(_soqt)
HAVE_UINTPTR_T = _soqt.HAVE_UINTPTR_T

_soqt.M_E_swigconstant(_soqt)
M_E = _soqt.M_E

_soqt.M_LOG2E_swigconstant(_soqt)
M_LOG2E = _soqt.M_LOG2E

_soqt.M_LOG10E_swigconstant(_soqt)
M_LOG10E = _soqt.M_LOG10E

_soqt.M_LN2_swigconstant(_soqt)
M_LN2 = _soqt.M_LN2

_soqt.M_LN10_swigconstant(_soqt)
M_LN10 = _soqt.M_LN10

_soqt.M_PI_swigconstant(_soqt)
M_PI = _soqt.M_PI

_soqt.M_TWOPI_swigconstant(_soqt)
M_TWOPI = _soqt.M_TWOPI

_soqt.M_PI_2_swigconstant(_soqt)
M_PI_2 = _soqt.M_PI_2

_soqt.M_PI_4_swigconstant(_soqt)
M_PI_4 = _soqt.M_PI_4

_soqt.M_3PI_4_swigconstant(_soqt)
M_3PI_4 = _soqt.M_3PI_4

_soqt.M_SQRTPI_swigconstant(_soqt)
M_SQRTPI = _soqt.M_SQRTPI

_soqt.M_1_PI_swigconstant(_soqt)
M_1_PI = _soqt.M_1_PI

_soqt.M_2_PI_swigconstant(_soqt)
M_2_PI = _soqt.M_2_PI

_soqt.M_2_SQRTPI_swigconstant(_soqt)
M_2_SQRTPI = _soqt.M_2_SQRTPI

_soqt.M_SQRT2_swigconstant(_soqt)
M_SQRT2 = _soqt.M_SQRT2

_soqt.M_SQRT1_2_swigconstant(_soqt)
M_SQRT1_2 = _soqt.M_SQRT1_2

_soqt.M_LN2LO_swigconstant(_soqt)
M_LN2LO = _soqt.M_LN2LO

_soqt.M_LN2HI_swigconstant(_soqt)
M_LN2HI = _soqt.M_LN2HI

_soqt.M_SQRT3_swigconstant(_soqt)
M_SQRT3 = _soqt.M_SQRT3

_soqt.M_IVLN10_swigconstant(_soqt)
M_IVLN10 = _soqt.M_IVLN10

_soqt.M_LOG2_E_swigconstant(_soqt)
M_LOG2_E = _soqt.M_LOG2_E

_soqt.M_INVLN2_swigconstant(_soqt)
M_INVLN2 = _soqt.M_INVLN2

_soqt.COIN_MAJOR_VERSION_swigconstant(_soqt)
COIN_MAJOR_VERSION = _soqt.COIN_MAJOR_VERSION

_soqt.COIN_MINOR_VERSION_swigconstant(_soqt)
COIN_MINOR_VERSION = _soqt.COIN_MINOR_VERSION

_soqt.COIN_MICRO_VERSION_swigconstant(_soqt)
COIN_MICRO_VERSION = _soqt.COIN_MICRO_VERSION

_soqt.COIN_VERSION_swigconstant(_soqt)
COIN_VERSION = _soqt.COIN_VERSION

_soqt.HAVE_HASH_QUOTING_swigconstant(_soqt)
HAVE_HASH_QUOTING = _soqt.HAVE_HASH_QUOTING

_soqt.SUN_CC_4_0_SOTYPE_INIT_BUG_swigconstant(_soqt)
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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SbDict
    __del__ = lambda self: None

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

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

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

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

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

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

    def setHashingFunction(self, func):
        return _soqt.SbDict_setHashingFunction(self, func)
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):
        return _soqt.SoType_getName(self)

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

    def isDerivedFrom(self, type):
        return _soqt.SoType_isDerivedFrom(self, type)
    getAllDerivedFrom = staticmethod(_soqt.SoType_getAllDerivedFrom)

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

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

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

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

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

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

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

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

    def __gt__(self, type):
        return _soqt.SoType___gt__(self, type)
    removeType = staticmethod(_soqt.SoType_removeType)
    init = staticmethod(_soqt.SoType_init)
    fromKey = staticmethod(_soqt.SoType_fromKey)
    badType = staticmethod(_soqt.SoType_badType)

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

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

    def isInternal(self):
        return _soqt.SoType_isInternal(self)
    getNumTypes = staticmethod(_soqt.SoType_getNumTypes)

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

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

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

def SoType_fromName(name):
    return _soqt.SoType_fromName(name)
SoType_fromName = _soqt.SoType_fromName

def SoType_getAllDerivedFrom(type, list):
    return _soqt.SoType_getAllDerivedFrom(type, list)
SoType_getAllDerivedFrom = _soqt.SoType_getAllDerivedFrom

def SoType_removeType(name):
    return _soqt.SoType_removeType(name)
SoType_removeType = _soqt.SoType_removeType

def SoType_init():
    return _soqt.SoType_init()
SoType_init = _soqt.SoType_init

def SoType_fromKey(key):
    return _soqt.SoType_fromKey(key)
SoType_fromKey = _soqt.SoType_fromKey

def SoType_badType():
    return _soqt.SoType_badType()
SoType_badType = _soqt.SoType_badType

def SoType_getNumTypes():
    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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SbPList
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:
            self.this = this

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

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

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

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

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

    def get(self, i):
        return _soqt.SbIntList_get(self, i)
    __swig_destroy__ = _soqt.delete_SbIntList
    __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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SbString
    __del__ = lambda self: None
    hash = staticmethod(_soqt.SbString_hash)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


    def __repr__(self):
        return _soqt.SbString___repr__(self)
SbString_swigregister = _soqt.SbString_swigregister
SbString_swigregister(SbString)

def SbString_hash(*args):
    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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SbName
    __del__ = lambda self: None

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

    def getLength(self):
        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):
        return _soqt.SbName___eq__(self, *args)

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

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

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


    def __repr__(self):
        return _soqt.SbName___repr__(self)
SbName_swigregister = _soqt.SbName_swigregister
SbName_swigregister(SbName)

def SbName_isIdentStartChar(c):
    return _soqt.SbName_isIdentStartChar(c)
SbName_isIdentStartChar = _soqt.SbName_isIdentStartChar

def SbName_isIdentChar(c):
    return _soqt.SbName_isIdentChar(c)
SbName_isIdentChar = _soqt.SbName_isIdentChar

def SbName_isBaseNameStartChar(c):
    return _soqt.SbName_isBaseNameStartChar(c)
SbName_isBaseNameStartChar = _soqt.SbName_isBaseNameStartChar

def SbName_isBaseNameChar(c):
    return _soqt.SbName_isBaseNameChar(c)
SbName_isBaseNameChar = _soqt.SbName_isBaseNameChar

def SbName_empty():
    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:
            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):
        return _soqt.SoError_getDebugString(self)
    getClassTypeId = staticmethod(_soqt.SoError_getClassTypeId)

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

    def isOfType(self, type):
        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, data):
    return _soqt.SoError_setHandlerCallback(func, data)
SoError_setHandlerCallback = _soqt.SoError_setHandlerCallback

def SoError_getHandlerCallback():
    return _soqt.SoError_getHandlerCallback()
SoError_getHandlerCallback = _soqt.SoError_getHandlerCallback

def SoError_getHandlerData():
    return _soqt.SoError_getHandlerData()
SoError_getHandlerData = _soqt.SoError_getHandlerData

def SoError_getClassTypeId():
    return _soqt.SoError_getClassTypeId()
SoError_getClassTypeId = _soqt.SoError_getClassTypeId

def SoError_post(format):
    return _soqt.SoError_post(format)
SoError_post = _soqt.SoError_post

def SoError_getString(*args):
    return _soqt.SoError_getString(*args)
SoError_getString = _soqt.SoError_getString

def SoError_initClass():
    return _soqt.SoError_initClass()
SoError_initClass = _soqt.SoError_initClass

def SoError_initClasses():
    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):
        return _soqt.SoDebugError_getTypeId(self)

    def getSeverity(self):
        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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoDebugError
    __del__ = lambda self: None
SoDebugError_swigregister = _soqt.SoDebugError_swigregister
SoDebugError_swigregister(SoDebugError)

def SoDebugError_setHandlerCallback(function, data):
    return _soqt.SoDebugError_setHandlerCallback(function, data)
SoDebugError_setHandlerCallback = _soqt.SoDebugError_setHandlerCallback

def SoDebugError_getHandlerCallback():
    return _soqt.SoDebugError_getHandlerCallback()
SoDebugError_getHandlerCallback = _soqt.SoDebugError_getHandlerCallback

def SoDebugError_getHandlerData():
    return _soqt.SoDebugError_getHandlerData()
SoDebugError_getHandlerData = _soqt.SoDebugError_getHandlerData

def SoDebugError_getClassTypeId():
    return _soqt.SoDebugError_getClassTypeId()
SoDebugError_getClassTypeId = _soqt.SoDebugError_getClassTypeId

def SoDebugError_post(source, format):
    return _soqt.SoDebugError_post(source, format)
SoDebugError_post = _soqt.SoDebugError_post

def SoDebugError_postWarning(source, format):
    return _soqt.SoDebugError_postWarning(source, format)
SoDebugError_postWarning = _soqt.SoDebugError_postWarning

def SoDebugError_postInfo(source, format):
    return _soqt.SoDebugError_postInfo(source, format)
SoDebugError_postInfo = _soqt.SoDebugError_postInfo

def SoDebugError_initClass():
    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:
            self.this = this

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

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

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

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

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

    def __idiv__(self, *args):
        return _soqt.SbVec2s___idiv__(self, *args)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __len__(self):
          return 2

    __swig_destroy__ = _soqt.delete_SbVec2s
    __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:
            self.this = this
    getTimeOfDay = staticmethod(_soqt.SbTime_getTimeOfDay)

    def setToTimeOfDay(self):
        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):
        return _soqt.SbTime_setValue(self, *args)

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

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

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

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

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

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

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

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

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

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

    def __idiv__(self, s):
        return _soqt.SbTime___idiv__(self, s)

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

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

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

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

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

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

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

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

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

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

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

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

    def __div__(self, *args):
        return _soqt.SbTime___div__(self, *args)
    __swig_destroy__ = _soqt.delete_SbTime
    __del__ = lambda self: None
SbTime_swigregister = _soqt.SbTime_swigregister
SbTime_swigregister(SbTime)

def SbTime_getTimeOfDay():
    return _soqt.SbTime_getTimeOfDay()
SbTime_getTimeOfDay = _soqt.SbTime_getTimeOfDay

def SbTime_zero():
    return _soqt.SbTime_zero()
SbTime_zero = _soqt.SbTime_zero

def SbTime_max():
    return _soqt.SbTime_max()
SbTime_max = _soqt.SbTime_max

def SbTime_maxTime():
    return _soqt.SbTime_maxTime()
SbTime_maxTime = _soqt.SbTime_maxTime

def SbTime_sleep(msec):
    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

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

    def isOfType(self, type):
        return _soqt.SoEvent_isOfType(self, type)
    getClassTypeId = staticmethod(_soqt.SoEvent_getClassTypeId)

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

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

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

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

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

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

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

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

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

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

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

    def wasAltDown(self):
        return _soqt.SoEvent_wasAltDown(self)
    initClass = staticmethod(_soqt.SoEvent_initClass)
SoEvent_swigregister = _soqt.SoEvent_swigregister
SoEvent_swigregister(SoEvent)

def SoEvent_getClassTypeId():
    return _soqt.SoEvent_getClassTypeId()
SoEvent_getClassTypeId = _soqt.SoEvent_getClassTypeId

def SoEvent_initClass():
    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

    def __init__(self, notifbase):
        this = _soqt.new_SoNotRec(notifbase)
        try:
            self.this.append(this)
        except:
            self.this = this

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

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

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

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

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

    def output(self, file):
        return _soqt.SoNotRec_output(self, file)
    __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:
            self.this = this

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

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

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

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

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

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

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

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

    def output(self, *args):
        return _soqt.SoNotList_output(self, *args)
    __swig_destroy__ = _soqt.delete_SoNotList
    __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):
        return _soqt.SoField_setIgnored(self, ignore)

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

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

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

    def getTypeId(self):
        return _soqt.SoField_getTypeId(self)
    getClassTypeId = staticmethod(_soqt.SoField_getClassTypeId)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def get(self):
        return _soqt.SoField_get(self)
SoField_swigregister = _soqt.SoField_swigregister
SoField_swigregister(SoField)

def SoField_initClass():
    return _soqt.SoField_initClass()
SoField_initClass = _soqt.SoField_initClass

def SoField_initClasses():
    return _soqt.SoField_initClasses()
SoField_initClasses = _soqt.SoField_initClasses

def SoField_cleanupClass():
    return _soqt.SoField_cleanupClass()
SoField_cleanupClass = _soqt.SoField_cleanupClass

def SoField_getClassTypeId():
    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():
    return _soqt.SoSField_initClass()
SoSField_initClass = _soqt.SoSField_initClass

def SoSField_getClassTypeId():
    return _soqt.SoSField_getClassTypeId()
SoSField_getClassTypeId = _soqt.SoSField_getClassTypeId

def SoSField_atexit_cleanup():
    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):
        return _soqt.SoMField_getNum(self)

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

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

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

    def set1(self, index, valuestring):
        return _soqt.SoMField_set1(self, index, valuestring)
    initClass = staticmethod(_soqt.SoMField_initClass)

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

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

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


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

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

def SoMField_getClassTypeId():
    return _soqt.SoMField_getClassTypeId()
SoMField_getClassTypeId = _soqt.SoMField_getClassTypeId

def SoMField_atexit_cleanup():
    return _soqt.SoMField_atexit_cleanup()
SoMField_atexit_cleanup = _soqt.SoMField_atexit_cleanup

def SoMField_initClass():
    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.SOQT_MAJOR_VERSION_swigconstant(_soqt)
SOQT_MAJOR_VERSION = _soqt.SOQT_MAJOR_VERSION

_soqt.SOQT_MINOR_VERSION_swigconstant(_soqt)
SOQT_MINOR_VERSION = _soqt.SOQT_MINOR_VERSION

_soqt.SOQT_MICRO_VERSION_swigconstant(_soqt)
SOQT_MICRO_VERSION = _soqt.SOQT_MICRO_VERSION

_soqt.SOQT_VERSION_swigconstant(_soqt)
SOQT_VERSION = _soqt.SOQT_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():
        """initClass()"""
        return _soqt.SoQtObject_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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


    def init():
        """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():
    """SoQtObject_initClass()"""
    return _soqt.SoQtObject_initClass()

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

def SoQtObject_init():
    """SoQtObject_init()"""
    return _soqt.SoQtObject_init()


_soqt.SOQT_SUN_CC_4_0_SOTYPE_INIT_BUG_swigconstant(_soqt)
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():
        """initClass()"""
        return _soqt.SoQtDevice_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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

    __swig_destroy__ = _soqt.delete_SoQtDevice
    __del__ = lambda self: None

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


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


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


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


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


    def initClasses():
        """initClasses()"""
        return _soqt.SoQtDevice_initClasses()

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

def SoQtDevice_initClass():
    """SoQtDevice_initClass()"""
    return _soqt.SoQtDevice_initClass()

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

def SoQtDevice_initClasses():
    """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():
        """initClass()"""
        return _soqt.SoQtKeyboard_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def createInstance():
        """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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtKeyboard
    __del__ = lambda self: None

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


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


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

SoQtKeyboard_swigregister = _soqt.SoQtKeyboard_swigregister
SoQtKeyboard_swigregister(SoQtKeyboard)

def SoQtKeyboard_initClass():
    """SoQtKeyboard_initClass()"""
    return _soqt.SoQtKeyboard_initClass()

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

def SoQtKeyboard_createInstance():
    """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():
        """initClass()"""
        return _soqt.SoQtMouse_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def createInstance():
        """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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtMouse
    __del__ = lambda self: None

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


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


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

SoQtMouse_swigregister = _soqt.SoQtMouse_swigregister
SoQtMouse_swigregister(SoQtMouse)

def SoQtMouse_initClass():
    """SoQtMouse_initClass()"""
    return _soqt.SoQtMouse_initClass()

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

def SoQtMouse_createInstance():
    """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):
        """
        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():
        """exitMainLoop()"""
        return _soqt.SoQt_exitMainLoop()

    exitMainLoop = staticmethod(exitMainLoop)

    def done():
        """done()"""
        return _soqt.SoQt_done()

    done = staticmethod(done)

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

    getTopLevelWidget = staticmethod(getTopLevelWidget)

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

    getShellWidget = staticmethod(getShellWidget)

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

    show = staticmethod(show)

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

    hide = staticmethod(hide)

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

    setWidgetSize = staticmethod(setWidgetSize)

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

    getWidgetSize = staticmethod(getWidgetSize)

    def createSimpleErrorDialog(widget, title, string1, string2=None):
        """
        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=None, minor=None, micro=None):
        """
        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():
        """getVersionString() -> char const *"""
        return _soqt.SoQt_getVersionString()

    getVersionString = staticmethod(getVersionString)

    def getVersionToolkitString():
        """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, userdata):
        """setFatalErrorHandler(SoQt::FatalErrorCB * cb, void * userdata) -> SoQt::FatalErrorCB *"""
        return _soqt.SoQt_setFatalErrorHandler(cb, userdata)

    setFatalErrorHandler = staticmethod(setFatalErrorHandler)

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

    isDebugLibrary = staticmethod(isDebugLibrary)

    def isCompatible(major, minor):
        """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():
        """getABIType() -> SoQt::ABIType"""
        return _soqt.SoQt_getABIType()

    getABIType = staticmethod(getABIType)

    def lockGL():
        """lockGL()"""
        return _soqt.SoQt_lockGL()

    lockGL = staticmethod(lockGL)

    def unlockGL():
        """unlockGL()"""
        return _soqt.SoQt_unlockGL()

    unlockGL = staticmethod(unlockGL)

    def mainLoop():
        """mainLoop()"""
        return _soqt.SoQt_mainLoop()

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

def SoQt_init(*args):
    """
    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():
    """SoQt_exitMainLoop()"""
    return _soqt.SoQt_exitMainLoop()

def SoQt_done():
    """SoQt_done()"""
    return _soqt.SoQt_done()

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

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

def SoQt_show(widget):
    """SoQt_show(QWidget widget)"""
    return _soqt.SoQt_show(widget)

def SoQt_hide(widget):
    """SoQt_hide(QWidget widget)"""
    return _soqt.SoQt_hide(widget)

def SoQt_setWidgetSize(widget, size):
    """SoQt_setWidgetSize(QWidget widget, SbVec2s size)"""
    return _soqt.SoQt_setWidgetSize(widget, size)

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

def SoQt_createSimpleErrorDialog(widget, title, string1, string2=None):
    """
    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=None, minor=None, micro=None):
    """
    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():
    """SoQt_getVersionString() -> char const *"""
    return _soqt.SoQt_getVersionString()

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

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

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

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

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

def SoQt_lockGL():
    """SoQt_lockGL()"""
    return _soqt.SoQt_lockGL()

def SoQt_unlockGL():
    """SoQt_unlockGL()"""
    return _soqt.SoQt_unlockGL()

def SoQt_mainLoop():
    """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():
        """initClass()"""
        return _soqt.SoQtComponent_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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

    __swig_destroy__ = _soqt.delete_SoQtComponent
    __del__ = lambda self: None

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


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


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


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

    setWidgetCursor = staticmethod(setWidgetCursor)

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def setWindowCloseCallback(self, func, user=None):
        """
        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):
        """getComponent(QWidget widget) -> SoQtComponent"""
        return _soqt.SoQtComponent_getComponent(widget)

    getComponent = staticmethod(getComponent)

    def initClasses():
        """initClasses()"""
        return _soqt.SoQtComponent_initClasses()

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

def SoQtComponent_initClass():
    """SoQtComponent_initClass()"""
    return _soqt.SoQtComponent_initClass()

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

def SoQtComponent_setWidgetCursor(w, cursor):
    """SoQtComponent_setWidgetCursor(QWidget w, SoQtCursor cursor)"""
    return _soqt.SoQtComponent_setWidgetCursor(w, cursor)

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

def SoQtComponent_initClasses():
    """SoQtComponent_initClasses()"""
    return _soqt.SoQtComponent_initClasses()


_soqt.SO_GL_RGB_swigconstant(_soqt)
SO_GL_RGB = _soqt.SO_GL_RGB

_soqt.SO_GLX_RGB_swigconstant(_soqt)
SO_GLX_RGB = _soqt.SO_GLX_RGB

_soqt.SO_GL_DOUBLE_swigconstant(_soqt)
SO_GL_DOUBLE = _soqt.SO_GL_DOUBLE

_soqt.SO_GLX_DOUBLE_swigconstant(_soqt)
SO_GLX_DOUBLE = _soqt.SO_GLX_DOUBLE

_soqt.SO_GL_ZBUFFER_swigconstant(_soqt)
SO_GL_ZBUFFER = _soqt.SO_GL_ZBUFFER

_soqt.SO_GLX_ZBUFFER_swigconstant(_soqt)
SO_GLX_ZBUFFER = _soqt.SO_GLX_ZBUFFER

_soqt.SO_GL_OVERLAY_swigconstant(_soqt)
SO_GL_OVERLAY = _soqt.SO_GL_OVERLAY

_soqt.SO_GLX_OVERLAY_swigconstant(_soqt)
SO_GLX_OVERLAY = _soqt.SO_GLX_OVERLAY

_soqt.SO_GL_STEREO_swigconstant(_soqt)
SO_GL_STEREO = _soqt.SO_GL_STEREO

_soqt.SO_GLX_STEREO_swigconstant(_soqt)
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():
        """initClass()"""
        return _soqt.SoQtGLWidget_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def getLineWidthLimits(self, range, granularity):
        """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():
    """SoQtGLWidget_initClass()"""
    return _soqt.SoQtGLWidget_initClass()

def SoQtGLWidget_getClassTypeId():
    """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():
        """initClass()"""
        return _soqt.SoQtRenderArea_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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

    createInstance = staticmethod(createInstance)

    def __init__(self, parent=None, name=None, embed=1, mouseInput=1, keyboardInput=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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtRenderArea
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

    getDefaultRedrawPriority = staticmethod(getDefaultRedrawPriority)

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def setEventCallback(self, *args):
        """
        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():
    """SoQtRenderArea_initClass()"""
    return _soqt.SoQtRenderArea_initClass()

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

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

def SoQtRenderArea_getDefaultRedrawPriority():
    """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():
        """initClass()"""
        return _soqt.SoQtViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def setAutoClippingStrategy(self, strategy, value=0.6, cb=None, cbuserdata=None):
        """
        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):
        """setStereoViewing(SoQtViewer self, SbBool enable)"""
        return _soqt.SoQtViewer_setStereoViewing(self, enable)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

SoQtViewer_swigregister = _soqt.SoQtViewer_swigregister
SoQtViewer_swigregister(SoQtViewer)

def SoQtViewer_initClass():
    """SoQtViewer_initClass()"""
    return _soqt.SoQtViewer_initClass()

def SoQtViewer_getClassTypeId():
    """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():
        """initClass()"""
        return _soqt.SoQtFullViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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


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


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


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


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


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


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


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


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


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


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


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

SoQtFullViewer_swigregister = _soqt.SoQtFullViewer_swigregister
SoQtFullViewer_swigregister(SoQtFullViewer)

def SoQtFullViewer_initClass():
    """SoQtFullViewer_initClass()"""
    return _soqt.SoQtFullViewer_initClass()

def SoQtFullViewer_getClassTypeId():
    """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():
        """initClass()"""
        return _soqt.SoQtPlaneViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def createInstance():
        """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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtPlaneViewer
    __del__ = lambda self: None

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


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


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

SoQtPlaneViewer_swigregister = _soqt.SoQtPlaneViewer_swigregister
SoQtPlaneViewer_swigregister(SoQtPlaneViewer)

def SoQtPlaneViewer_initClass():
    """SoQtPlaneViewer_initClass()"""
    return _soqt.SoQtPlaneViewer_initClass()

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

def SoQtPlaneViewer_createInstance():
    """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():
        """initClass()"""
        return _soqt.SoQtExaminerViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def createInstance():
        """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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtExaminerViewer
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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


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

SoQtExaminerViewer_swigregister = _soqt.SoQtExaminerViewer_swigregister
SoQtExaminerViewer_swigregister(SoQtExaminerViewer)

def SoQtExaminerViewer_initClass():
    """SoQtExaminerViewer_initClass()"""
    return _soqt.SoQtExaminerViewer_initClass()

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

def SoQtExaminerViewer_createInstance():
    """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():
        """initClass()"""
        return _soqt.SoQtConstrainedViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


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


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


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


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


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

SoQtConstrainedViewer_swigregister = _soqt.SoQtConstrainedViewer_swigregister
SoQtConstrainedViewer_swigregister(SoQtConstrainedViewer)

def SoQtConstrainedViewer_initClass():
    """SoQtConstrainedViewer_initClass()"""
    return _soqt.SoQtConstrainedViewer_initClass()

def SoQtConstrainedViewer_getClassTypeId():
    """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():
        """initClass()"""
        return _soqt.SoQtFlyViewer_initClass()

    initClass = staticmethod(initClass)

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

    getClassTypeId = staticmethod(getClassTypeId)

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


    def createInstance():
        """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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtFlyViewer
    __del__ = lambda self: None

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


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


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


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


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


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

SoQtFlyViewer_swigregister = _soqt.SoQtFlyViewer_swigregister
SoQtFlyViewer_swigregister(SoQtFlyViewer)

def SoQtFlyViewer_initClass():
    """SoQtFlyViewer_initClass()"""
    return _soqt.SoQtFlyViewer_initClass()

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

def SoQtFlyViewer_createInstance():
    """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():
        """createInstance() -> SoQtPopupMenu"""
        return _soqt.SoQtPopupMenu_createInstance()

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

    def newMenu(self, name, menuid=-1):
        """
        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):
        """getMenu(SoQtPopupMenu self, char const * name) -> int"""
        return _soqt.SoQtPopupMenu_getMenu(self, name)


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


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


    def newMenuItem(self, name, itemid=-1):
        """
        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):
        """getMenuItem(SoQtPopupMenu self, char const * name) -> int"""
        return _soqt.SoQtPopupMenu_getMenuItem(self, name)


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


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


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


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


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


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


    def addMenu(self, menuid, submenuid, pos=-1):
        """
        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, itemid, pos=-1):
        """
        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, pos=-1):
        """
        addSeparator(SoQtPopupMenu self, int menuid, int pos=-1)
        addSeparator(SoQtPopupMenu self, int menuid)
        """
        return _soqt.SoQtPopupMenu_addSeparator(self, menuid, pos)


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


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


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


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


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


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


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


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


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


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


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


    def removeMenuSelectionCallback(self, callback, data):
        """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_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():
        """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:
            self.this = this
    __swig_destroy__ = _soqt.delete_SoQtCursor
    __del__ = lambda self: None

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


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


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


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

    getZoomCursor = staticmethod(getZoomCursor)

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

    getPanCursor = staticmethod(getPanCursor)

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

    getRotateCursor = staticmethod(getRotateCursor)

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

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

def SoQtCursor_initClass():
    """SoQtCursor_initClass()"""
    return _soqt.SoQtCursor_initClass()

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

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

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

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



