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



from sys import version_info
if version_info >= (3,0,0):
    new_instancemethod = lambda func, inst, cls: _enigma.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
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('_enigma', [dirname(__file__)])
        except ImportError:
            import _enigma
            return _enigma
        if fp is not None:
            try:
                _mod = imp.load_module('_enigma', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _enigma = swig_import_helper()
    del swig_import_helper
else:
    import _enigma
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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


__ENIGMA_PYTHON_I_INSIDE__ = _enigma.__ENIGMA_PYTHON_I_INSIDE__
COMPOSITION_MODE_BUFFERED = _enigma.COMPOSITION_MODE_BUFFERED
DEBUG = _enigma.DEBUG
DISPLAY_FBDEV = _enigma.DISPLAY_FBDEV
ENABLE_EWEBVIEW = _enigma.ENABLE_EWEBVIEW
ENABLE_LCD = _enigma.ENABLE_LCD
HAVE_DLFCN_H = _enigma.HAVE_DLFCN_H
HAVE_INTTYPES_H = _enigma.HAVE_INTTYPES_H
HAVE_LIBSYSTEMD_DAEMON = _enigma.HAVE_LIBSYSTEMD_DAEMON
HAVE_MEMORY_H = _enigma.HAVE_MEMORY_H
HAVE_PTHREAD = _enigma.HAVE_PTHREAD
HAVE_PYTHON = _enigma.HAVE_PYTHON
HAVE_QT = _enigma.HAVE_QT
HAVE_QT_GUI = _enigma.HAVE_QT_GUI
HAVE_QWEBSETTINGS_WEBSECURITY_ENABLED = _enigma.HAVE_QWEBSETTINGS_WEBSECURITY_ENABLED
HAVE_SIGC20 = _enigma.HAVE_SIGC20
HAVE_STDINT_H = _enigma.HAVE_STDINT_H
HAVE_STDLIB_H = _enigma.HAVE_STDLIB_H
HAVE_STRINGS_H = _enigma.HAVE_STRINGS_H
HAVE_STRING_H = _enigma.HAVE_STRING_H
HAVE_SYS_STAT_H = _enigma.HAVE_SYS_STAT_H
HAVE_SYS_TYPES_H = _enigma.HAVE_SYS_TYPES_H
HAVE_UNISTD_H = _enigma.HAVE_UNISTD_H
HAVE_V3DDRIVER = _enigma.HAVE_V3DDRIVER
LT_OBJDIR = _enigma.LT_OBJDIR
PACKAGE_BUGREPORT = _enigma.PACKAGE_BUGREPORT
PACKAGE_NAME = _enigma.PACKAGE_NAME
PACKAGE_STRING = _enigma.PACKAGE_STRING
PACKAGE_TARNAME = _enigma.PACKAGE_TARNAME
PACKAGE_URL = _enigma.PACKAGE_URL
PACKAGE_VERSION = _enigma.PACKAGE_VERSION
STDC_HEADERS = _enigma.STDC_HEADERS
_ALL_SOURCE = _enigma._ALL_SOURCE
_GNU_SOURCE = _enigma._GNU_SOURCE
_POSIX_PTHREAD_SEMANTICS = _enigma._POSIX_PTHREAD_SEMANTICS
_TANDEM_SOURCE = _enigma._TANDEM_SOURCE
__EXTENSIONS__ = _enigma.__EXTENSIONS__
_DARWIN_USE_64_BIT_INODE = _enigma._DARWIN_USE_64_BIT_INODE
_FILE_OFFSET_BITS = _enigma._FILE_OFFSET_BITS
class SwigPyIterator(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__ = _enigma.delete_SwigPyIterator
    def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_enigma.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_enigma.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_enigma.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_enigma.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_enigma.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_enigma.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_enigma.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_enigma.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_enigma.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_enigma.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_enigma.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_enigma.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_enigma.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_enigma.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_enigma.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_enigma.SwigPyIterator___sub__,None,SwigPyIterator)
SwigPyIterator_swigregister = _enigma.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class iObject(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__ = _enigma.delete_iObject
iObject_swigregister = _enigma.iObject_swigregister
iObject_swigregister(iObject)

class eMainloop(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
eMainloop.runLoop = new_instancemethod(_enigma.eMainloop_runLoop,None,eMainloop)
eMainloop.isIdle = new_instancemethod(_enigma.eMainloop_isIdle,None,eMainloop)
eMainloop.idleCount = new_instancemethod(_enigma.eMainloop_idleCount,None,eMainloop)
eMainloop.argc = new_instancemethod(_enigma.eMainloop_argc,None,eMainloop)
eMainloop.argv = new_instancemethod(_enigma.eMainloop_argv,None,eMainloop)
eMainloop_swigregister = _enigma.eMainloop_swigregister
eMainloop_swigregister(eMainloop)
cvar = _enigma.cvar

class eSocketNotifier(iObject):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Read = _enigma.eSocketNotifier_Read
    Write = _enigma.eSocketNotifier_Write
    Priority = _enigma.eSocketNotifier_Priority
    Error = _enigma.eSocketNotifier_Error
    Hungup = _enigma.eSocketNotifier_Hungup
    __swig_destroy__ = _enigma.delete_eSocketNotifier
    activated = _swig_property(_enigma.eSocketNotifier_activated_get, _enigma.eSocketNotifier_activated_set)
    def __init__(self, *args): 
        _enigma.eSocketNotifier_swiginit(self,_enigma.new_eSocketNotifier(*args))
eSocketNotifier.start = new_instancemethod(_enigma.eSocketNotifier_start,None,eSocketNotifier)
eSocketNotifier.stop = new_instancemethod(_enigma.eSocketNotifier_stop,None,eSocketNotifier)
eSocketNotifier.isRunning = new_instancemethod(_enigma.eSocketNotifier_isRunning,None,eSocketNotifier)
eSocketNotifier.getFD = new_instancemethod(_enigma.eSocketNotifier_getFD,None,eSocketNotifier)
eSocketNotifier.getRequested = new_instancemethod(_enigma.eSocketNotifier_getRequested,None,eSocketNotifier)
eSocketNotifier.setRequested = new_instancemethod(_enigma.eSocketNotifier_setRequested,None,eSocketNotifier)
eSocketNotifier.getState = new_instancemethod(_enigma.eSocketNotifier_getState,None,eSocketNotifier)
eSocketNotifier.activate = new_instancemethod(_enigma.eSocketNotifier_activate,None,eSocketNotifier)
eSocketNotifier_swigregister = _enigma.eSocketNotifier_swigregister
eSocketNotifier_swigregister(eSocketNotifier)

class eTimer(iObject):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _enigma.delete_eTimer
    timeout = _swig_property(_enigma.eTimer_timeout_get, _enigma.eTimer_timeout_set)
    def __init__(self): 
        _enigma.eTimer_swiginit(self,_enigma.new_eTimer())
eTimer.isActive = new_instancemethod(_enigma.eTimer_isActive,None,eTimer)
eTimer.getNextActivation = new_instancemethod(_enigma.eTimer_getNextActivation,None,eTimer)
eTimer.getInterval = new_instancemethod(_enigma.eTimer_getInterval,None,eTimer)
eTimer.activate = new_instancemethod(_enigma.eTimer_activate,None,eTimer)
eTimer.start = new_instancemethod(_enigma.eTimer_start,None,eTimer)
eTimer.stop = new_instancemethod(_enigma.eTimer_stop,None,eTimer)
eTimer.changeInterval = new_instancemethod(_enigma.eTimer_changeInterval,None,eTimer)
eTimer.startLongTimer = new_instancemethod(_enigma.eTimer_startLongTimer,None,eTimer)
eTimer_swigregister = _enigma.eTimer_swigregister
eTimer_swigregister(eTimer)

class eConsoleAppContainer(iObject):
    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): 
        _enigma.eConsoleAppContainer_swiginit(self,_enigma.new_eConsoleAppContainer())
    __swig_destroy__ = _enigma.delete_eConsoleAppContainer
    dataAvail = _swig_property(_enigma.eConsoleAppContainer_dataAvail_get, _enigma.eConsoleAppContainer_dataAvail_set)
    stdoutAvail = _swig_property(_enigma.eConsoleAppContainer_stdoutAvail_get, _enigma.eConsoleAppContainer_stdoutAvail_set)
    stderrAvail = _swig_property(_enigma.eConsoleAppContainer_stderrAvail_get, _enigma.eConsoleAppContainer_stderrAvail_set)
    dataSent = _swig_property(_enigma.eConsoleAppContainer_dataSent_get, _enigma.eConsoleAppContainer_dataSent_set)
    appClosed = _swig_property(_enigma.eConsoleAppContainer_appClosed_get, _enigma.eConsoleAppContainer_appClosed_set)
    def execute(self, *args):
        if len(args) > 1:
            return self.exec2(args[0], args[1:])
        return self.exec1(args[0])
eConsoleAppContainer.setCWD = new_instancemethod(_enigma.eConsoleAppContainer_setCWD,None,eConsoleAppContainer)
eConsoleAppContainer.exec1 = new_instancemethod(_enigma.eConsoleAppContainer_exec1,None,eConsoleAppContainer)
eConsoleAppContainer.exec2 = new_instancemethod(_enigma.eConsoleAppContainer_exec2,None,eConsoleAppContainer)
eConsoleAppContainer.getPID = new_instancemethod(_enigma.eConsoleAppContainer_getPID,None,eConsoleAppContainer)
eConsoleAppContainer.kill = new_instancemethod(_enigma.eConsoleAppContainer_kill,None,eConsoleAppContainer)
eConsoleAppContainer.sendCtrlC = new_instancemethod(_enigma.eConsoleAppContainer_sendCtrlC,None,eConsoleAppContainer)
eConsoleAppContainer.sendEOF = new_instancemethod(_enigma.eConsoleAppContainer_sendEOF,None,eConsoleAppContainer)
eConsoleAppContainer.write = new_instancemethod(_enigma.eConsoleAppContainer_write,None,eConsoleAppContainer)
eConsoleAppContainer.setFileFD = new_instancemethod(_enigma.eConsoleAppContainer_setFileFD,None,eConsoleAppContainer)
eConsoleAppContainer.running = new_instancemethod(_enigma.eConsoleAppContainer_running,None,eConsoleAppContainer)
eConsoleAppContainer_swigregister = _enigma.eConsoleAppContainer_swigregister
eConsoleAppContainer_swigregister(eConsoleAppContainer)

class eDict(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): 
        _enigma.eDict_swiginit(self,_enigma.new_eDict())
    __swig_destroy__ = _enigma.delete_eDict
eDict.flag = new_instancemethod(_enigma.eDict_flag,None,eDict)
eDict.setFlag = new_instancemethod(_enigma.eDict_setFlag,None,eDict)
eDict.string = new_instancemethod(_enigma.eDict_string,None,eDict)
eDict.setString = new_instancemethod(_enigma.eDict_setString,None,eDict)
eDict_swigregister = _enigma.eDict_swigregister
eDict_swigregister(eDict)

class eDictList(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): 
        _enigma.eDictList_swiginit(self,_enigma.new_eDictList())
    __swig_destroy__ = _enigma.delete_eDictList
eDictList.push_back = new_instancemethod(_enigma.eDictList_push_back,None,eDictList)
eDictList_swigregister = _enigma.eDictList_swigregister
eDictList_swigregister(eDictList)

class eEnv(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    resolve = staticmethod(_enigma.eEnv_resolve)
    def __init__(self): 
        _enigma.eEnv_swiginit(self,_enigma.new_eEnv())
    __swig_destroy__ = _enigma.delete_eEnv
eEnv_swigregister = _enigma.eEnv_swigregister
eEnv_swigregister(eEnv)

def eEnv_resolve(*args):
  return _enigma.eEnv_resolve(*args)
eEnv_resolve = _enigma.eEnv_resolve

NULL = _enigma.NULL

def ptrAssert(*args):
  return _enigma.ptrAssert(*args)
ptrAssert = _enigma.ptrAssert
MALLOC = _enigma.MALLOC
NEW = _enigma.NEW
class BufferPtr(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): 
        _enigma.BufferPtr_swiginit(self,_enigma.new_BufferPtr(*args))
    __swig_destroy__ = _enigma.delete_BufferPtr
BufferPtr.__ref__ = new_instancemethod(_enigma.BufferPtr___ref__,None,BufferPtr)
BufferPtr.getPtrString = new_instancemethod(_enigma.BufferPtr_getPtrString,None,BufferPtr)
BufferPtr.__deref__ = new_instancemethod(_enigma.BufferPtr___deref__,None,BufferPtr)
BufferPtr.data = new_instancemethod(_enigma.BufferPtr_data,None,BufferPtr)
BufferPtr.size = new_instancemethod(_enigma.BufferPtr_size,None,BufferPtr)
BufferPtr.setBuffer = new_instancemethod(_enigma.BufferPtr_setBuffer,None,BufferPtr)
BufferPtr.setSize = new_instancemethod(_enigma.BufferPtr_setSize,None,BufferPtr)
BufferPtr_swigregister = _enigma.BufferPtr_swigregister
BufferPtr_swigregister(BufferPtr)

class eServiceEvent(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): 
        _enigma.eServiceEvent_swiginit(self,_enigma.new_eServiceEvent(*args))
    __swig_destroy__ = _enigma.delete_eServiceEvent
    setEPGLanguage = staticmethod(_enigma.eServiceEvent_setEPGLanguage)
eServiceEvent.__ref__ = new_instancemethod(_enigma.eServiceEvent___ref__,None,eServiceEvent)
eServiceEvent.getPtrString = new_instancemethod(_enigma.eServiceEvent_getPtrString,None,eServiceEvent)
eServiceEvent.__deref__ = new_instancemethod(_enigma.eServiceEvent___deref__,None,eServiceEvent)
eServiceEvent.getBeginTime = new_instancemethod(_enigma.eServiceEvent_getBeginTime,None,eServiceEvent)
eServiceEvent.getDuration = new_instancemethod(_enigma.eServiceEvent_getDuration,None,eServiceEvent)
eServiceEvent.getEventId = new_instancemethod(_enigma.eServiceEvent_getEventId,None,eServiceEvent)
eServiceEvent.getEventName = new_instancemethod(_enigma.eServiceEvent_getEventName,None,eServiceEvent)
eServiceEvent.getShortDescription = new_instancemethod(_enigma.eServiceEvent_getShortDescription,None,eServiceEvent)
eServiceEvent.getExtendedDescription = new_instancemethod(_enigma.eServiceEvent_getExtendedDescription,None,eServiceEvent)
eServiceEvent.getBeginTimeString = new_instancemethod(_enigma.eServiceEvent_getBeginTimeString,None,eServiceEvent)
eServiceEvent.getNumComponent = new_instancemethod(_enigma.eServiceEvent_getNumComponent,None,eServiceEvent)
eServiceEvent.getComponentData = new_instancemethod(_enigma.eServiceEvent_getComponentData,None,eServiceEvent)
eServiceEvent.getNumOfLinkageServices = new_instancemethod(_enigma.eServiceEvent_getNumOfLinkageServices,None,eServiceEvent)
eServiceEvent.getLinkageService = new_instancemethod(_enigma.eServiceEvent_getLinkageService,None,eServiceEvent)
eServiceEvent_swigregister = _enigma.eServiceEvent_swigregister
eServiceEvent_swigregister(eServiceEvent)

def eServiceEvent_setEPGLanguage(*args):
  return _enigma.eServiceEvent_setEPGLanguage(*args)
eServiceEvent_setEPGLanguage = _enigma.eServiceEvent_setEPGLanguage

class eServiceReference(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    idInvalid = _enigma.eServiceReference_idInvalid
    idStructure = _enigma.eServiceReference_idStructure
    idDVB = _enigma.eServiceReference_idDVB
    idFile = _enigma.eServiceReference_idFile
    idUser = _enigma.eServiceReference_idUser
    type = _swig_property(_enigma.eServiceReference_type_get, _enigma.eServiceReference_type_set)
    isDirectory = _enigma.eServiceReference_isDirectory
    mustDescent = _enigma.eServiceReference_mustDescent
    canDescent = _enigma.eServiceReference_canDescent
    flagDirectory = _enigma.eServiceReference_flagDirectory
    shouldSort = _enigma.eServiceReference_shouldSort
    hasSortKey = _enigma.eServiceReference_hasSortKey
    sort1 = _enigma.eServiceReference_sort1
    isMarker = _enigma.eServiceReference_isMarker
    isGroup = _enigma.eServiceReference_isGroup
    isMulticast = _enigma.eServiceReference_isMulticast
    mustJoinMulticastGroup = _enigma.eServiceReference_mustJoinMulticastGroup
    flags = _swig_property(_enigma.eServiceReference_flags_get, _enigma.eServiceReference_flags_set)
    def __init__(self, *args): 
        _enigma.eServiceReference_swiginit(self,_enigma.new_eServiceReference(*args))
    __swig_destroy__ = _enigma.delete_eServiceReference
eServiceReference.getSortKey = new_instancemethod(_enigma.eServiceReference_getSortKey,None,eServiceReference)
eServiceReference.getPath = new_instancemethod(_enigma.eServiceReference_getPath,None,eServiceReference)
eServiceReference.setPath = new_instancemethod(_enigma.eServiceReference_setPath,None,eServiceReference)
eServiceReference.getUnsignedData = new_instancemethod(_enigma.eServiceReference_getUnsignedData,None,eServiceReference)
eServiceReference.getData = new_instancemethod(_enigma.eServiceReference_getData,None,eServiceReference)
eServiceReference.setUnsignedData = new_instancemethod(_enigma.eServiceReference_setUnsignedData,None,eServiceReference)
eServiceReference.setData = new_instancemethod(_enigma.eServiceReference_setData,None,eServiceReference)
eServiceReference.getName = new_instancemethod(_enigma.eServiceReference_getName,None,eServiceReference)
eServiceReference.setName = new_instancemethod(_enigma.eServiceReference_setName,None,eServiceReference)
eServiceReference.toString = new_instancemethod(_enigma.eServiceReference_toString,None,eServiceReference)
eServiceReference.toCompareString = new_instancemethod(_enigma.eServiceReference_toCompareString,None,eServiceReference)
eServiceReference.__eq__ = new_instancemethod(_enigma.eServiceReference___eq__,None,eServiceReference)
eServiceReference.__ne__ = new_instancemethod(_enigma.eServiceReference___ne__,None,eServiceReference)
eServiceReference.__lt__ = new_instancemethod(_enigma.eServiceReference___lt__,None,eServiceReference)
eServiceReference.valid = new_instancemethod(_enigma.eServiceReference_valid,None,eServiceReference)
eServiceReference.compare = new_instancemethod(_enigma.eServiceReference_compare,None,eServiceReference)
eServiceReference.hash = new_instancemethod(_enigma.eServiceReference_hash,None,eServiceReference)
eServiceReference_swigregister = _enigma.eServiceReference_swigregister
eServiceReference_swigregister(eServiceReference)

eServiceReference.__hash__ = eServiceReference.hash

def New_eServiceReference(*args):
  return _enigma.New_eServiceReference(*args)
New_eServiceReference = _enigma.New_eServiceReference
class iStaticServiceInformationPtr(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): 
        _enigma.iStaticServiceInformationPtr_swiginit(self,_enigma.new_iStaticServiceInformationPtr(*args))
    __swig_destroy__ = _enigma.delete_iStaticServiceInformationPtr
iStaticServiceInformationPtr.__ref__ = new_instancemethod(_enigma.iStaticServiceInformationPtr___ref__,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.getPtrString = new_instancemethod(_enigma.iStaticServiceInformationPtr_getPtrString,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.__deref__ = new_instancemethod(_enigma.iStaticServiceInformationPtr___deref__,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.getName = new_instancemethod(_enigma.iStaticServiceInformationPtr_getName,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.getLength = new_instancemethod(_enigma.iStaticServiceInformationPtr_getLength,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.getEvent = new_instancemethod(_enigma.iStaticServiceInformationPtr_getEvent,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.isPlayable = new_instancemethod(_enigma.iStaticServiceInformationPtr_isPlayable,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.getInfo = new_instancemethod(_enigma.iStaticServiceInformationPtr_getInfo,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.getInfoString = new_instancemethod(_enigma.iStaticServiceInformationPtr_getInfoString,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.getInfoObject = new_instancemethod(_enigma.iStaticServiceInformationPtr_getInfoObject,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.setInfo = new_instancemethod(_enigma.iStaticServiceInformationPtr_setInfo,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr.setInfoString = new_instancemethod(_enigma.iStaticServiceInformationPtr_setInfoString,None,iStaticServiceInformationPtr)
iStaticServiceInformationPtr_swigregister = _enigma.iStaticServiceInformationPtr_swigregister
iStaticServiceInformationPtr_swigregister(iStaticServiceInformationPtr)

class iServiceInformation_ENUMS(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")
    __repr__ = _swig_repr
    sIsCrypted = _enigma.iServiceInformation_ENUMS_sIsCrypted
    sAspect = _enigma.iServiceInformation_ENUMS_sAspect
    sFrameRate = _enigma.iServiceInformation_ENUMS_sFrameRate
    sProgressive = _enigma.iServiceInformation_ENUMS_sProgressive
    sIsMultichannel = _enigma.iServiceInformation_ENUMS_sIsMultichannel
    sVideoPID = _enigma.iServiceInformation_ENUMS_sVideoPID
    sAudioPID = _enigma.iServiceInformation_ENUMS_sAudioPID
    sPCRPID = _enigma.iServiceInformation_ENUMS_sPCRPID
    sPMTPID = _enigma.iServiceInformation_ENUMS_sPMTPID
    sTXTPID = _enigma.iServiceInformation_ENUMS_sTXTPID
    sSID = _enigma.iServiceInformation_ENUMS_sSID
    sONID = _enigma.iServiceInformation_ENUMS_sONID
    sTSID = _enigma.iServiceInformation_ENUMS_sTSID
    sNamespace = _enigma.iServiceInformation_ENUMS_sNamespace
    sProvider = _enigma.iServiceInformation_ENUMS_sProvider
    sDescription = _enigma.iServiceInformation_ENUMS_sDescription
    sDatabaseFileId = _enigma.iServiceInformation_ENUMS_sDatabaseFileId
    sServiceref = _enigma.iServiceInformation_ENUMS_sServiceref
    sTimeCreate = _enigma.iServiceInformation_ENUMS_sTimeCreate
    sFileSize = _enigma.iServiceInformation_ENUMS_sFileSize
    sCAIDs = _enigma.iServiceInformation_ENUMS_sCAIDs
    sCAIDPIDs = _enigma.iServiceInformation_ENUMS_sCAIDPIDs
    sVideoType = _enigma.iServiceInformation_ENUMS_sVideoType
    sTags = _enigma.iServiceInformation_ENUMS_sTags
    sDVBState = _enigma.iServiceInformation_ENUMS_sDVBState
    sVideoHeight = _enigma.iServiceInformation_ENUMS_sVideoHeight
    sVideoWidth = _enigma.iServiceInformation_ENUMS_sVideoWidth
    sTransponderData = _enigma.iServiceInformation_ENUMS_sTransponderData
    sCurrentChapter = _enigma.iServiceInformation_ENUMS_sCurrentChapter
    sCurrentTitle = _enigma.iServiceInformation_ENUMS_sCurrentTitle
    sTotalChapters = _enigma.iServiceInformation_ENUMS_sTotalChapters
    sTotalTitles = _enigma.iServiceInformation_ENUMS_sTotalTitles
    sTagTitle = _enigma.iServiceInformation_ENUMS_sTagTitle
    sTagTitleSortname = _enigma.iServiceInformation_ENUMS_sTagTitleSortname
    sTagArtist = _enigma.iServiceInformation_ENUMS_sTagArtist
    sTagArtistSortname = _enigma.iServiceInformation_ENUMS_sTagArtistSortname
    sTagAlbum = _enigma.iServiceInformation_ENUMS_sTagAlbum
    sTagAlbumSortname = _enigma.iServiceInformation_ENUMS_sTagAlbumSortname
    sTagComposer = _enigma.iServiceInformation_ENUMS_sTagComposer
    sTagDate = _enigma.iServiceInformation_ENUMS_sTagDate
    sTagGenre = _enigma.iServiceInformation_ENUMS_sTagGenre
    sTagComment = _enigma.iServiceInformation_ENUMS_sTagComment
    sTagExtendedComment = _enigma.iServiceInformation_ENUMS_sTagExtendedComment
    sTagTrackNumber = _enigma.iServiceInformation_ENUMS_sTagTrackNumber
    sTagTrackCount = _enigma.iServiceInformation_ENUMS_sTagTrackCount
    sTagAlbumVolumeNumber = _enigma.iServiceInformation_ENUMS_sTagAlbumVolumeNumber
    sTagAlbumVolumeCount = _enigma.iServiceInformation_ENUMS_sTagAlbumVolumeCount
    sTagLocation = _enigma.iServiceInformation_ENUMS_sTagLocation
    sTagHomepage = _enigma.iServiceInformation_ENUMS_sTagHomepage
    sTagDescription = _enigma.iServiceInformation_ENUMS_sTagDescription
    sTagVersion = _enigma.iServiceInformation_ENUMS_sTagVersion
    sTagISRC = _enigma.iServiceInformation_ENUMS_sTagISRC
    sTagOrganization = _enigma.iServiceInformation_ENUMS_sTagOrganization
    sTagCopyright = _enigma.iServiceInformation_ENUMS_sTagCopyright
    sTagCopyrightURI = _enigma.iServiceInformation_ENUMS_sTagCopyrightURI
    sTagContact = _enigma.iServiceInformation_ENUMS_sTagContact
    sTagLicense = _enigma.iServiceInformation_ENUMS_sTagLicense
    sTagLicenseURI = _enigma.iServiceInformation_ENUMS_sTagLicenseURI
    sTagPerformer = _enigma.iServiceInformation_ENUMS_sTagPerformer
    sTagCodec = _enigma.iServiceInformation_ENUMS_sTagCodec
    sTagVideoCodec = _enigma.iServiceInformation_ENUMS_sTagVideoCodec
    sTagAudioCodec = _enigma.iServiceInformation_ENUMS_sTagAudioCodec
    sTagBitrate = _enigma.iServiceInformation_ENUMS_sTagBitrate
    sTagNominalBitrate = _enigma.iServiceInformation_ENUMS_sTagNominalBitrate
    sTagMinimumBitrate = _enigma.iServiceInformation_ENUMS_sTagMinimumBitrate
    sTagMaximumBitrate = _enigma.iServiceInformation_ENUMS_sTagMaximumBitrate
    sTagSerial = _enigma.iServiceInformation_ENUMS_sTagSerial
    sTagEncoder = _enigma.iServiceInformation_ENUMS_sTagEncoder
    sTagEncoderVersion = _enigma.iServiceInformation_ENUMS_sTagEncoderVersion
    sTagTrackGain = _enigma.iServiceInformation_ENUMS_sTagTrackGain
    sTagTrackPeak = _enigma.iServiceInformation_ENUMS_sTagTrackPeak
    sTagAlbumGain = _enigma.iServiceInformation_ENUMS_sTagAlbumGain
    sTagAlbumPeak = _enigma.iServiceInformation_ENUMS_sTagAlbumPeak
    sTagReferenceLevel = _enigma.iServiceInformation_ENUMS_sTagReferenceLevel
    sTagLanguageCode = _enigma.iServiceInformation_ENUMS_sTagLanguageCode
    sTagImage = _enigma.iServiceInformation_ENUMS_sTagImage
    sTagPreviewImage = _enigma.iServiceInformation_ENUMS_sTagPreviewImage
    sTagAttachment = _enigma.iServiceInformation_ENUMS_sTagAttachment
    sTagBeatsPerMinute = _enigma.iServiceInformation_ENUMS_sTagBeatsPerMinute
    sTagKeywords = _enigma.iServiceInformation_ENUMS_sTagKeywords
    sTagCRC = _enigma.iServiceInformation_ENUMS_sTagCRC
    sTagChannelMode = _enigma.iServiceInformation_ENUMS_sTagChannelMode
    sTransferBPS = _enigma.iServiceInformation_ENUMS_sTransferBPS
    sLastUpdated = _enigma.iServiceInformation_ENUMS_sLastUpdated
    sUser = _enigma.iServiceInformation_ENUMS_sUser
    resNA = _enigma.iServiceInformation_ENUMS_resNA
    resIsString = _enigma.iServiceInformation_ENUMS_resIsString
    resIsPyObject = _enigma.iServiceInformation_ENUMS_resIsPyObject
iServiceInformation_ENUMS_swigregister = _enigma.iServiceInformation_ENUMS_swigregister
iServiceInformation_ENUMS_swigregister(iServiceInformation_ENUMS)

iServiceInformation = iServiceInformation_ENUMS
class iServiceInformationPtr(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): 
        _enigma.iServiceInformationPtr_swiginit(self,_enigma.new_iServiceInformationPtr(*args))
    __swig_destroy__ = _enigma.delete_iServiceInformationPtr
iServiceInformationPtr.__ref__ = new_instancemethod(_enigma.iServiceInformationPtr___ref__,None,iServiceInformationPtr)
iServiceInformationPtr.getPtrString = new_instancemethod(_enigma.iServiceInformationPtr_getPtrString,None,iServiceInformationPtr)
iServiceInformationPtr.__deref__ = new_instancemethod(_enigma.iServiceInformationPtr___deref__,None,iServiceInformationPtr)
iServiceInformationPtr.getName = new_instancemethod(_enigma.iServiceInformationPtr_getName,None,iServiceInformationPtr)
iServiceInformationPtr.getEvent = new_instancemethod(_enigma.iServiceInformationPtr_getEvent,None,iServiceInformationPtr)
iServiceInformationPtr.getInfo = new_instancemethod(_enigma.iServiceInformationPtr_getInfo,None,iServiceInformationPtr)
iServiceInformationPtr.getInfoString = new_instancemethod(_enigma.iServiceInformationPtr_getInfoString,None,iServiceInformationPtr)
iServiceInformationPtr.getInfoObject = new_instancemethod(_enigma.iServiceInformationPtr_getInfoObject,None,iServiceInformationPtr)
iServiceInformationPtr.setInfo = new_instancemethod(_enigma.iServiceInformationPtr_setInfo,None,iServiceInformationPtr)
iServiceInformationPtr.setInfoString = new_instancemethod(_enigma.iServiceInformationPtr_setInfoString,None,iServiceInformationPtr)
iServiceInformationPtr_swigregister = _enigma.iServiceInformationPtr_swigregister
iServiceInformationPtr_swigregister(iServiceInformationPtr)

class iFrontendInformation_ENUMS(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")
    __repr__ = _swig_repr
    bitErrorRate = _enigma.iFrontendInformation_ENUMS_bitErrorRate
    signalPower = _enigma.iFrontendInformation_ENUMS_signalPower
    signalQuality = _enigma.iFrontendInformation_ENUMS_signalQuality
    lockState = _enigma.iFrontendInformation_ENUMS_lockState
    syncState = _enigma.iFrontendInformation_ENUMS_syncState
    frontendNumber = _enigma.iFrontendInformation_ENUMS_frontendNumber
    signalQualitydB = _enigma.iFrontendInformation_ENUMS_signalQualitydB
iFrontendInformation_ENUMS_swigregister = _enigma.iFrontendInformation_ENUMS_swigregister
iFrontendInformation_ENUMS_swigregister(iFrontendInformation_ENUMS)

iFrontendInformation = iFrontendInformation_ENUMS
class iFrontendInformationPtr(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): 
        _enigma.iFrontendInformationPtr_swiginit(self,_enigma.new_iFrontendInformationPtr(*args))
    __swig_destroy__ = _enigma.delete_iFrontendInformationPtr
iFrontendInformationPtr.__ref__ = new_instancemethod(_enigma.iFrontendInformationPtr___ref__,None,iFrontendInformationPtr)
iFrontendInformationPtr.getPtrString = new_instancemethod(_enigma.iFrontendInformationPtr_getPtrString,None,iFrontendInformationPtr)
iFrontendInformationPtr.__deref__ = new_instancemethod(_enigma.iFrontendInformationPtr___deref__,None,iFrontendInformationPtr)
iFrontendInformationPtr.getFrontendInfo = new_instancemethod(_enigma.iFrontendInformationPtr_getFrontendInfo,None,iFrontendInformationPtr)
iFrontendInformationPtr.getFrontendData = new_instancemethod(_enigma.iFrontendInformationPtr_getFrontendData,None,iFrontendInformationPtr)
iFrontendInformationPtr.getFrontendStatus = new_instancemethod(_enigma.iFrontendInformationPtr_getFrontendStatus,None,iFrontendInformationPtr)
iFrontendInformationPtr.getTransponderData = new_instancemethod(_enigma.iFrontendInformationPtr_getTransponderData,None,iFrontendInformationPtr)
iFrontendInformationPtr.getAll = new_instancemethod(_enigma.iFrontendInformationPtr_getAll,None,iFrontendInformationPtr)
iFrontendInformationPtr_swigregister = _enigma.iFrontendInformationPtr_swigregister
iFrontendInformationPtr_swigregister(iFrontendInformationPtr)

class iPauseableServicePtr(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): 
        _enigma.iPauseableServicePtr_swiginit(self,_enigma.new_iPauseableServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iPauseableServicePtr
iPauseableServicePtr.__ref__ = new_instancemethod(_enigma.iPauseableServicePtr___ref__,None,iPauseableServicePtr)
iPauseableServicePtr.getPtrString = new_instancemethod(_enigma.iPauseableServicePtr_getPtrString,None,iPauseableServicePtr)
iPauseableServicePtr.__deref__ = new_instancemethod(_enigma.iPauseableServicePtr___deref__,None,iPauseableServicePtr)
iPauseableServicePtr.pause = new_instancemethod(_enigma.iPauseableServicePtr_pause,None,iPauseableServicePtr)
iPauseableServicePtr.unpause = new_instancemethod(_enigma.iPauseableServicePtr_unpause,None,iPauseableServicePtr)
iPauseableServicePtr.setSlowMotion = new_instancemethod(_enigma.iPauseableServicePtr_setSlowMotion,None,iPauseableServicePtr)
iPauseableServicePtr.setFastForward = new_instancemethod(_enigma.iPauseableServicePtr_setFastForward,None,iPauseableServicePtr)
iPauseableServicePtr_swigregister = _enigma.iPauseableServicePtr_swigregister
iPauseableServicePtr_swigregister(iPauseableServicePtr)

class iSeekableService_ENUMS(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")
    __repr__ = _swig_repr
    dirForward = _enigma.iSeekableService_ENUMS_dirForward
    dirBackward = _enigma.iSeekableService_ENUMS_dirBackward
iSeekableService_ENUMS_swigregister = _enigma.iSeekableService_ENUMS_swigregister
iSeekableService_ENUMS_swigregister(iSeekableService_ENUMS)

iSeekableService = iSeekableService_ENUMS
class iSeekableServicePtr(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): 
        _enigma.iSeekableServicePtr_swiginit(self,_enigma.new_iSeekableServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iSeekableServicePtr
iSeekableServicePtr.__ref__ = new_instancemethod(_enigma.iSeekableServicePtr___ref__,None,iSeekableServicePtr)
iSeekableServicePtr.getPtrString = new_instancemethod(_enigma.iSeekableServicePtr_getPtrString,None,iSeekableServicePtr)
iSeekableServicePtr.__deref__ = new_instancemethod(_enigma.iSeekableServicePtr___deref__,None,iSeekableServicePtr)
iSeekableServicePtr.getLength = new_instancemethod(_enigma.iSeekableServicePtr_getLength,None,iSeekableServicePtr)
iSeekableServicePtr.seekTo = new_instancemethod(_enigma.iSeekableServicePtr_seekTo,None,iSeekableServicePtr)
iSeekableServicePtr.seekRelative = new_instancemethod(_enigma.iSeekableServicePtr_seekRelative,None,iSeekableServicePtr)
iSeekableServicePtr.getPlayPosition = new_instancemethod(_enigma.iSeekableServicePtr_getPlayPosition,None,iSeekableServicePtr)
iSeekableServicePtr.setTrickmode = new_instancemethod(_enigma.iSeekableServicePtr_setTrickmode,None,iSeekableServicePtr)
iSeekableServicePtr.isCurrentlySeekable = new_instancemethod(_enigma.iSeekableServicePtr_isCurrentlySeekable,None,iSeekableServicePtr)
iSeekableServicePtr.seekChapter = new_instancemethod(_enigma.iSeekableServicePtr_seekChapter,None,iSeekableServicePtr)
iSeekableServicePtr.seekTitle = new_instancemethod(_enigma.iSeekableServicePtr_seekTitle,None,iSeekableServicePtr)
iSeekableServicePtr_swigregister = _enigma.iSeekableServicePtr_swigregister
iSeekableServicePtr_swigregister(iSeekableServicePtr)

class iAudioTrackInfo(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): 
        _enigma.iAudioTrackInfo_swiginit(self,_enigma.new_iAudioTrackInfo())
    __swig_destroy__ = _enigma.delete_iAudioTrackInfo
iAudioTrackInfo.getDescription = new_instancemethod(_enigma.iAudioTrackInfo_getDescription,None,iAudioTrackInfo)
iAudioTrackInfo.getLanguage = new_instancemethod(_enigma.iAudioTrackInfo_getLanguage,None,iAudioTrackInfo)
iAudioTrackInfo.getPID = new_instancemethod(_enigma.iAudioTrackInfo_getPID,None,iAudioTrackInfo)
iAudioTrackInfo_swigregister = _enigma.iAudioTrackInfo_swigregister
iAudioTrackInfo_swigregister(iAudioTrackInfo)

class iAudioTrackSelectionPtr(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): 
        _enigma.iAudioTrackSelectionPtr_swiginit(self,_enigma.new_iAudioTrackSelectionPtr(*args))
    __swig_destroy__ = _enigma.delete_iAudioTrackSelectionPtr
iAudioTrackSelectionPtr.__ref__ = new_instancemethod(_enigma.iAudioTrackSelectionPtr___ref__,None,iAudioTrackSelectionPtr)
iAudioTrackSelectionPtr.getPtrString = new_instancemethod(_enigma.iAudioTrackSelectionPtr_getPtrString,None,iAudioTrackSelectionPtr)
iAudioTrackSelectionPtr.__deref__ = new_instancemethod(_enigma.iAudioTrackSelectionPtr___deref__,None,iAudioTrackSelectionPtr)
iAudioTrackSelectionPtr.getNumberOfTracks = new_instancemethod(_enigma.iAudioTrackSelectionPtr_getNumberOfTracks,None,iAudioTrackSelectionPtr)
iAudioTrackSelectionPtr.selectTrack = new_instancemethod(_enigma.iAudioTrackSelectionPtr_selectTrack,None,iAudioTrackSelectionPtr)
iAudioTrackSelectionPtr.getTrackInfo = new_instancemethod(_enigma.iAudioTrackSelectionPtr_getTrackInfo,None,iAudioTrackSelectionPtr)
iAudioTrackSelectionPtr.getCurrentTrack = new_instancemethod(_enigma.iAudioTrackSelectionPtr_getCurrentTrack,None,iAudioTrackSelectionPtr)
iAudioTrackSelectionPtr_swigregister = _enigma.iAudioTrackSelectionPtr_swigregister
iAudioTrackSelectionPtr_swigregister(iAudioTrackSelectionPtr)

class iAudioChannelSelection_ENUMS(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")
    __repr__ = _swig_repr
    LEFT = _enigma.iAudioChannelSelection_ENUMS_LEFT
    STEREO = _enigma.iAudioChannelSelection_ENUMS_STEREO
    RIGHT = _enigma.iAudioChannelSelection_ENUMS_RIGHT
iAudioChannelSelection_ENUMS_swigregister = _enigma.iAudioChannelSelection_ENUMS_swigregister
iAudioChannelSelection_ENUMS_swigregister(iAudioChannelSelection_ENUMS)

iAudioChannelSelection = iAudioChannelSelection_ENUMS
class iAudioChannelSelectionPtr(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): 
        _enigma.iAudioChannelSelectionPtr_swiginit(self,_enigma.new_iAudioChannelSelectionPtr(*args))
    __swig_destroy__ = _enigma.delete_iAudioChannelSelectionPtr
iAudioChannelSelectionPtr.__ref__ = new_instancemethod(_enigma.iAudioChannelSelectionPtr___ref__,None,iAudioChannelSelectionPtr)
iAudioChannelSelectionPtr.getPtrString = new_instancemethod(_enigma.iAudioChannelSelectionPtr_getPtrString,None,iAudioChannelSelectionPtr)
iAudioChannelSelectionPtr.__deref__ = new_instancemethod(_enigma.iAudioChannelSelectionPtr___deref__,None,iAudioChannelSelectionPtr)
iAudioChannelSelectionPtr.getCurrentChannel = new_instancemethod(_enigma.iAudioChannelSelectionPtr_getCurrentChannel,None,iAudioChannelSelectionPtr)
iAudioChannelSelectionPtr.selectChannel = new_instancemethod(_enigma.iAudioChannelSelectionPtr_selectChannel,None,iAudioChannelSelectionPtr)
iAudioChannelSelectionPtr_swigregister = _enigma.iAudioChannelSelectionPtr_swigregister
iAudioChannelSelectionPtr_swigregister(iAudioChannelSelectionPtr)

class iAudioDelayPtr(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): 
        _enigma.iAudioDelayPtr_swiginit(self,_enigma.new_iAudioDelayPtr(*args))
    __swig_destroy__ = _enigma.delete_iAudioDelayPtr
iAudioDelayPtr.__ref__ = new_instancemethod(_enigma.iAudioDelayPtr___ref__,None,iAudioDelayPtr)
iAudioDelayPtr.getPtrString = new_instancemethod(_enigma.iAudioDelayPtr_getPtrString,None,iAudioDelayPtr)
iAudioDelayPtr.__deref__ = new_instancemethod(_enigma.iAudioDelayPtr___deref__,None,iAudioDelayPtr)
iAudioDelayPtr.getAC3Delay = new_instancemethod(_enigma.iAudioDelayPtr_getAC3Delay,None,iAudioDelayPtr)
iAudioDelayPtr.getPCMDelay = new_instancemethod(_enigma.iAudioDelayPtr_getPCMDelay,None,iAudioDelayPtr)
iAudioDelayPtr.setAC3Delay = new_instancemethod(_enigma.iAudioDelayPtr_setAC3Delay,None,iAudioDelayPtr)
iAudioDelayPtr.setPCMDelay = new_instancemethod(_enigma.iAudioDelayPtr_setPCMDelay,None,iAudioDelayPtr)
iAudioDelayPtr_swigregister = _enigma.iAudioDelayPtr_swigregister
iAudioDelayPtr_swigregister(iAudioDelayPtr)

class iRdsDecoder_ENUMS(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")
    __repr__ = _swig_repr
    RadioText = _enigma.iRdsDecoder_ENUMS_RadioText
    RtpText = _enigma.iRdsDecoder_ENUMS_RtpText
iRdsDecoder_ENUMS_swigregister = _enigma.iRdsDecoder_ENUMS_swigregister
iRdsDecoder_ENUMS_swigregister(iRdsDecoder_ENUMS)

iRdsDecoder = iRdsDecoder_ENUMS
class iRdsDecoderPtr(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): 
        _enigma.iRdsDecoderPtr_swiginit(self,_enigma.new_iRdsDecoderPtr(*args))
    __swig_destroy__ = _enigma.delete_iRdsDecoderPtr
iRdsDecoderPtr.__ref__ = new_instancemethod(_enigma.iRdsDecoderPtr___ref__,None,iRdsDecoderPtr)
iRdsDecoderPtr.getPtrString = new_instancemethod(_enigma.iRdsDecoderPtr_getPtrString,None,iRdsDecoderPtr)
iRdsDecoderPtr.__deref__ = new_instancemethod(_enigma.iRdsDecoderPtr___deref__,None,iRdsDecoderPtr)
iRdsDecoderPtr.getText = new_instancemethod(_enigma.iRdsDecoderPtr_getText,None,iRdsDecoderPtr)
iRdsDecoderPtr.showRassSlidePicture = new_instancemethod(_enigma.iRdsDecoderPtr_showRassSlidePicture,None,iRdsDecoderPtr)
iRdsDecoderPtr.showRassInteractivePic = new_instancemethod(_enigma.iRdsDecoderPtr_showRassInteractivePic,None,iRdsDecoderPtr)
iRdsDecoderPtr.getRassInteractiveMask = new_instancemethod(_enigma.iRdsDecoderPtr_getRassInteractiveMask,None,iRdsDecoderPtr)
iRdsDecoderPtr_swigregister = _enigma.iRdsDecoderPtr_swigregister
iRdsDecoderPtr_swigregister(iRdsDecoderPtr)

class iSubserviceListPtr(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): 
        _enigma.iSubserviceListPtr_swiginit(self,_enigma.new_iSubserviceListPtr(*args))
    __swig_destroy__ = _enigma.delete_iSubserviceListPtr
iSubserviceListPtr.__ref__ = new_instancemethod(_enigma.iSubserviceListPtr___ref__,None,iSubserviceListPtr)
iSubserviceListPtr.getPtrString = new_instancemethod(_enigma.iSubserviceListPtr_getPtrString,None,iSubserviceListPtr)
iSubserviceListPtr.__deref__ = new_instancemethod(_enigma.iSubserviceListPtr___deref__,None,iSubserviceListPtr)
iSubserviceListPtr.getNumberOfSubservices = new_instancemethod(_enigma.iSubserviceListPtr_getNumberOfSubservices,None,iSubserviceListPtr)
iSubserviceListPtr.getSubservice = new_instancemethod(_enigma.iSubserviceListPtr_getSubservice,None,iSubserviceListPtr)
iSubserviceListPtr_swigregister = _enigma.iSubserviceListPtr_swigregister
iSubserviceListPtr_swigregister(iSubserviceListPtr)

class iTimeshiftServicePtr(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): 
        _enigma.iTimeshiftServicePtr_swiginit(self,_enigma.new_iTimeshiftServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iTimeshiftServicePtr
iTimeshiftServicePtr.__ref__ = new_instancemethod(_enigma.iTimeshiftServicePtr___ref__,None,iTimeshiftServicePtr)
iTimeshiftServicePtr.getPtrString = new_instancemethod(_enigma.iTimeshiftServicePtr_getPtrString,None,iTimeshiftServicePtr)
iTimeshiftServicePtr.__deref__ = new_instancemethod(_enigma.iTimeshiftServicePtr___deref__,None,iTimeshiftServicePtr)
iTimeshiftServicePtr.startTimeshift = new_instancemethod(_enigma.iTimeshiftServicePtr_startTimeshift,None,iTimeshiftServicePtr)
iTimeshiftServicePtr.stopTimeshift = new_instancemethod(_enigma.iTimeshiftServicePtr_stopTimeshift,None,iTimeshiftServicePtr)
iTimeshiftServicePtr.setNextPlaybackFile = new_instancemethod(_enigma.iTimeshiftServicePtr_setNextPlaybackFile,None,iTimeshiftServicePtr)
iTimeshiftServicePtr.isTimeshiftActive = new_instancemethod(_enigma.iTimeshiftServicePtr_isTimeshiftActive,None,iTimeshiftServicePtr)
iTimeshiftServicePtr.activateTimeshift = new_instancemethod(_enigma.iTimeshiftServicePtr_activateTimeshift,None,iTimeshiftServicePtr)
iTimeshiftServicePtr_swigregister = _enigma.iTimeshiftServicePtr_swigregister
iTimeshiftServicePtr_swigregister(iTimeshiftServicePtr)

class iCueSheet_ENUMS(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")
    __repr__ = _swig_repr
    cutIn = _enigma.iCueSheet_ENUMS_cutIn
    cutOut = _enigma.iCueSheet_ENUMS_cutOut
    cutMark = _enigma.iCueSheet_ENUMS_cutMark
iCueSheet_ENUMS_swigregister = _enigma.iCueSheet_ENUMS_swigregister
iCueSheet_ENUMS_swigregister(iCueSheet_ENUMS)

iCueSheet = iCueSheet_ENUMS
class iCueSheetPtr(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): 
        _enigma.iCueSheetPtr_swiginit(self,_enigma.new_iCueSheetPtr(*args))
    __swig_destroy__ = _enigma.delete_iCueSheetPtr
iCueSheetPtr.__ref__ = new_instancemethod(_enigma.iCueSheetPtr___ref__,None,iCueSheetPtr)
iCueSheetPtr.getPtrString = new_instancemethod(_enigma.iCueSheetPtr_getPtrString,None,iCueSheetPtr)
iCueSheetPtr.__deref__ = new_instancemethod(_enigma.iCueSheetPtr___deref__,None,iCueSheetPtr)
iCueSheetPtr.getCutList = new_instancemethod(_enigma.iCueSheetPtr_getCutList,None,iCueSheetPtr)
iCueSheetPtr.setCutList = new_instancemethod(_enigma.iCueSheetPtr_setCutList,None,iCueSheetPtr)
iCueSheetPtr.setCutListEnable = new_instancemethod(_enigma.iCueSheetPtr_setCutListEnable,None,iCueSheetPtr)
iCueSheetPtr_swigregister = _enigma.iCueSheetPtr_swigregister
iCueSheetPtr_swigregister(iCueSheetPtr)

class iSubtitleOutputPtr(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): 
        _enigma.iSubtitleOutputPtr_swiginit(self,_enigma.new_iSubtitleOutputPtr(*args))
    __swig_destroy__ = _enigma.delete_iSubtitleOutputPtr
iSubtitleOutputPtr.__ref__ = new_instancemethod(_enigma.iSubtitleOutputPtr___ref__,None,iSubtitleOutputPtr)
iSubtitleOutputPtr.getPtrString = new_instancemethod(_enigma.iSubtitleOutputPtr_getPtrString,None,iSubtitleOutputPtr)
iSubtitleOutputPtr.__deref__ = new_instancemethod(_enigma.iSubtitleOutputPtr___deref__,None,iSubtitleOutputPtr)
iSubtitleOutputPtr.enableSubtitles = new_instancemethod(_enigma.iSubtitleOutputPtr_enableSubtitles,None,iSubtitleOutputPtr)
iSubtitleOutputPtr.disableSubtitles = new_instancemethod(_enigma.iSubtitleOutputPtr_disableSubtitles,None,iSubtitleOutputPtr)
iSubtitleOutputPtr.getSubtitleList = new_instancemethod(_enigma.iSubtitleOutputPtr_getSubtitleList,None,iSubtitleOutputPtr)
iSubtitleOutputPtr.getCachedSubtitle = new_instancemethod(_enigma.iSubtitleOutputPtr_getCachedSubtitle,None,iSubtitleOutputPtr)
iSubtitleOutputPtr_swigregister = _enigma.iSubtitleOutputPtr_swigregister
iSubtitleOutputPtr_swigregister(iSubtitleOutputPtr)

class iMutableServiceListPtr(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): 
        _enigma.iMutableServiceListPtr_swiginit(self,_enigma.new_iMutableServiceListPtr(*args))
    __swig_destroy__ = _enigma.delete_iMutableServiceListPtr
iMutableServiceListPtr.__ref__ = new_instancemethod(_enigma.iMutableServiceListPtr___ref__,None,iMutableServiceListPtr)
iMutableServiceListPtr.getPtrString = new_instancemethod(_enigma.iMutableServiceListPtr_getPtrString,None,iMutableServiceListPtr)
iMutableServiceListPtr.__deref__ = new_instancemethod(_enigma.iMutableServiceListPtr___deref__,None,iMutableServiceListPtr)
iMutableServiceListPtr.flushChanges = new_instancemethod(_enigma.iMutableServiceListPtr_flushChanges,None,iMutableServiceListPtr)
iMutableServiceListPtr.addService = new_instancemethod(_enigma.iMutableServiceListPtr_addService,None,iMutableServiceListPtr)
iMutableServiceListPtr.removeService = new_instancemethod(_enigma.iMutableServiceListPtr_removeService,None,iMutableServiceListPtr)
iMutableServiceListPtr.moveService = new_instancemethod(_enigma.iMutableServiceListPtr_moveService,None,iMutableServiceListPtr)
iMutableServiceListPtr.setListName = new_instancemethod(_enigma.iMutableServiceListPtr_setListName,None,iMutableServiceListPtr)
iMutableServiceListPtr_swigregister = _enigma.iMutableServiceListPtr_swigregister
iMutableServiceListPtr_swigregister(iMutableServiceListPtr)

class iListableServicePtr(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): 
        _enigma.iListableServicePtr_swiginit(self,_enigma.new_iListableServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iListableServicePtr
iListableServicePtr.__ref__ = new_instancemethod(_enigma.iListableServicePtr___ref__,None,iListableServicePtr)
iListableServicePtr.getPtrString = new_instancemethod(_enigma.iListableServicePtr_getPtrString,None,iListableServicePtr)
iListableServicePtr.__deref__ = new_instancemethod(_enigma.iListableServicePtr___deref__,None,iListableServicePtr)
iListableServicePtr.getContent = new_instancemethod(_enigma.iListableServicePtr_getContent,None,iListableServicePtr)
iListableServicePtr.getNext = new_instancemethod(_enigma.iListableServicePtr_getNext,None,iListableServicePtr)
iListableServicePtr.compareLessEqual = new_instancemethod(_enigma.iListableServicePtr_compareLessEqual,None,iListableServicePtr)
iListableServicePtr.startEdit = new_instancemethod(_enigma.iListableServicePtr_startEdit,None,iListableServicePtr)
iListableServicePtr_swigregister = _enigma.iListableServicePtr_swigregister
iListableServicePtr_swigregister(iListableServicePtr)

class iServiceOfflineOperationsPtr(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): 
        _enigma.iServiceOfflineOperationsPtr_swiginit(self,_enigma.new_iServiceOfflineOperationsPtr(*args))
    __swig_destroy__ = _enigma.delete_iServiceOfflineOperationsPtr
iServiceOfflineOperationsPtr.__ref__ = new_instancemethod(_enigma.iServiceOfflineOperationsPtr___ref__,None,iServiceOfflineOperationsPtr)
iServiceOfflineOperationsPtr.getPtrString = new_instancemethod(_enigma.iServiceOfflineOperationsPtr_getPtrString,None,iServiceOfflineOperationsPtr)
iServiceOfflineOperationsPtr.__deref__ = new_instancemethod(_enigma.iServiceOfflineOperationsPtr___deref__,None,iServiceOfflineOperationsPtr)
iServiceOfflineOperationsPtr.deleteFromDisk = new_instancemethod(_enigma.iServiceOfflineOperationsPtr_deleteFromDisk,None,iServiceOfflineOperationsPtr)
iServiceOfflineOperationsPtr.getListOfFilenames = new_instancemethod(_enigma.iServiceOfflineOperationsPtr_getListOfFilenames,None,iServiceOfflineOperationsPtr)
iServiceOfflineOperationsPtr.reindex = new_instancemethod(_enigma.iServiceOfflineOperationsPtr_reindex,None,iServiceOfflineOperationsPtr)
iServiceOfflineOperationsPtr_swigregister = _enigma.iServiceOfflineOperationsPtr_swigregister
iServiceOfflineOperationsPtr_swigregister(iServiceOfflineOperationsPtr)

class iStreamableServicePtr(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): 
        _enigma.iStreamableServicePtr_swiginit(self,_enigma.new_iStreamableServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iStreamableServicePtr
iStreamableServicePtr.__ref__ = new_instancemethod(_enigma.iStreamableServicePtr___ref__,None,iStreamableServicePtr)
iStreamableServicePtr.getPtrString = new_instancemethod(_enigma.iStreamableServicePtr_getPtrString,None,iStreamableServicePtr)
iStreamableServicePtr.__deref__ = new_instancemethod(_enigma.iStreamableServicePtr___deref__,None,iStreamableServicePtr)
iStreamableServicePtr.getStreamingData = new_instancemethod(_enigma.iStreamableServicePtr_getStreamingData,None,iStreamableServicePtr)
iStreamableServicePtr_swigregister = _enigma.iStreamableServicePtr_swigregister
iStreamableServicePtr_swigregister(iStreamableServicePtr)

class iStreamedServicePtr(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): 
        _enigma.iStreamedServicePtr_swiginit(self,_enigma.new_iStreamedServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iStreamedServicePtr
iStreamedServicePtr.__ref__ = new_instancemethod(_enigma.iStreamedServicePtr___ref__,None,iStreamedServicePtr)
iStreamedServicePtr.getPtrString = new_instancemethod(_enigma.iStreamedServicePtr_getPtrString,None,iStreamedServicePtr)
iStreamedServicePtr.__deref__ = new_instancemethod(_enigma.iStreamedServicePtr___deref__,None,iStreamedServicePtr)
iStreamedServicePtr.getBufferCharge = new_instancemethod(_enigma.iStreamedServicePtr_getBufferCharge,None,iStreamedServicePtr)
iStreamedServicePtr.setBufferSize = new_instancemethod(_enigma.iStreamedServicePtr_setBufferSize,None,iStreamedServicePtr)
iStreamedServicePtr_swigregister = _enigma.iStreamedServicePtr_swigregister
iStreamedServicePtr_swigregister(iStreamedServicePtr)

class iServiceKeys_ENUMS(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")
    __repr__ = _swig_repr
    keyLeft = _enigma.iServiceKeys_ENUMS_keyLeft
    keyRight = _enigma.iServiceKeys_ENUMS_keyRight
    keyUp = _enigma.iServiceKeys_ENUMS_keyUp
    keyDown = _enigma.iServiceKeys_ENUMS_keyDown
    keyOk = _enigma.iServiceKeys_ENUMS_keyOk
    keyUser = _enigma.iServiceKeys_ENUMS_keyUser
iServiceKeys_ENUMS_swigregister = _enigma.iServiceKeys_ENUMS_swigregister
iServiceKeys_ENUMS_swigregister(iServiceKeys_ENUMS)

iServiceKeys = iServiceKeys_ENUMS
class iServiceKeysPtr(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): 
        _enigma.iServiceKeysPtr_swiginit(self,_enigma.new_iServiceKeysPtr(*args))
    __swig_destroy__ = _enigma.delete_iServiceKeysPtr
iServiceKeysPtr.__ref__ = new_instancemethod(_enigma.iServiceKeysPtr___ref__,None,iServiceKeysPtr)
iServiceKeysPtr.getPtrString = new_instancemethod(_enigma.iServiceKeysPtr_getPtrString,None,iServiceKeysPtr)
iServiceKeysPtr.__deref__ = new_instancemethod(_enigma.iServiceKeysPtr___deref__,None,iServiceKeysPtr)
iServiceKeysPtr.keyPressed = new_instancemethod(_enigma.iServiceKeysPtr_keyPressed,None,iServiceKeysPtr)
iServiceKeysPtr_swigregister = _enigma.iServiceKeysPtr_swigregister
iServiceKeysPtr_swigregister(iServiceKeysPtr)

class iHbbtvPtr(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): 
        _enigma.iHbbtvPtr_swiginit(self,_enigma.new_iHbbtvPtr(*args))
    __swig_destroy__ = _enigma.delete_iHbbtvPtr
iHbbtvPtr.__ref__ = new_instancemethod(_enigma.iHbbtvPtr___ref__,None,iHbbtvPtr)
iHbbtvPtr.getPtrString = new_instancemethod(_enigma.iHbbtvPtr_getPtrString,None,iHbbtvPtr)
iHbbtvPtr.__deref__ = new_instancemethod(_enigma.iHbbtvPtr___deref__,None,iHbbtvPtr)
iHbbtvPtr_swigregister = _enigma.iHbbtvPtr_swigregister
iHbbtvPtr_swigregister(iHbbtvPtr)

class iPlayableService_ENUMS(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")
    __repr__ = _swig_repr
    evStart = _enigma.iPlayableService_ENUMS_evStart
    evEnd = _enigma.iPlayableService_ENUMS_evEnd
    evTunedIn = _enigma.iPlayableService_ENUMS_evTunedIn
    evTuneFailed = _enigma.iPlayableService_ENUMS_evTuneFailed
    evUpdatedEventInfo = _enigma.iPlayableService_ENUMS_evUpdatedEventInfo
    evUpdatedInfo = _enigma.iPlayableService_ENUMS_evUpdatedInfo
    evSeekableStatusChanged = _enigma.iPlayableService_ENUMS_evSeekableStatusChanged
    evEOF = _enigma.iPlayableService_ENUMS_evEOF
    evSOF = _enigma.iPlayableService_ENUMS_evSOF
    evCuesheetChanged = _enigma.iPlayableService_ENUMS_evCuesheetChanged
    evUpdatedRadioText = _enigma.iPlayableService_ENUMS_evUpdatedRadioText
    evUpdatedRtpText = _enigma.iPlayableService_ENUMS_evUpdatedRtpText
    evUpdatedRassSlidePic = _enigma.iPlayableService_ENUMS_evUpdatedRassSlidePic
    evUpdatedRassInteractivePicMask = _enigma.iPlayableService_ENUMS_evUpdatedRassInteractivePicMask
    evVideoSizeChanged = _enigma.iPlayableService_ENUMS_evVideoSizeChanged
    evVideoFramerateChanged = _enigma.iPlayableService_ENUMS_evVideoFramerateChanged
    evVideoProgressiveChanged = _enigma.iPlayableService_ENUMS_evVideoProgressiveChanged
    evBuffering = _enigma.iPlayableService_ENUMS_evBuffering
    evStopped = _enigma.iPlayableService_ENUMS_evStopped
    evUser = _enigma.iPlayableService_ENUMS_evUser
iPlayableService_ENUMS_swigregister = _enigma.iPlayableService_ENUMS_swigregister
iPlayableService_ENUMS_swigregister(iPlayableService_ENUMS)

iPlayableService = iPlayableService_ENUMS
class iPlayableServicePtr(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): 
        _enigma.iPlayableServicePtr_swiginit(self,_enigma.new_iPlayableServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iPlayableServicePtr
iPlayableServicePtr.__ref__ = new_instancemethod(_enigma.iPlayableServicePtr___ref__,None,iPlayableServicePtr)
iPlayableServicePtr.getPtrString = new_instancemethod(_enigma.iPlayableServicePtr_getPtrString,None,iPlayableServicePtr)
iPlayableServicePtr.__deref__ = new_instancemethod(_enigma.iPlayableServicePtr___deref__,None,iPlayableServicePtr)
iPlayableServicePtr.start = new_instancemethod(_enigma.iPlayableServicePtr_start,None,iPlayableServicePtr)
iPlayableServicePtr.stop = new_instancemethod(_enigma.iPlayableServicePtr_stop,None,iPlayableServicePtr)
iPlayableServicePtr.setTarget = new_instancemethod(_enigma.iPlayableServicePtr_setTarget,None,iPlayableServicePtr)
iPlayableServicePtr.seek = new_instancemethod(_enigma.iPlayableServicePtr_seek,None,iPlayableServicePtr)
iPlayableServicePtr.pause = new_instancemethod(_enigma.iPlayableServicePtr_pause,None,iPlayableServicePtr)
iPlayableServicePtr.info = new_instancemethod(_enigma.iPlayableServicePtr_info,None,iPlayableServicePtr)
iPlayableServicePtr.audioTracks = new_instancemethod(_enigma.iPlayableServicePtr_audioTracks,None,iPlayableServicePtr)
iPlayableServicePtr.audioChannel = new_instancemethod(_enigma.iPlayableServicePtr_audioChannel,None,iPlayableServicePtr)
iPlayableServicePtr.subServices = new_instancemethod(_enigma.iPlayableServicePtr_subServices,None,iPlayableServicePtr)
iPlayableServicePtr.frontendInfo = new_instancemethod(_enigma.iPlayableServicePtr_frontendInfo,None,iPlayableServicePtr)
iPlayableServicePtr.timeshift = new_instancemethod(_enigma.iPlayableServicePtr_timeshift,None,iPlayableServicePtr)
iPlayableServicePtr.cueSheet = new_instancemethod(_enigma.iPlayableServicePtr_cueSheet,None,iPlayableServicePtr)
iPlayableServicePtr.subtitle = new_instancemethod(_enigma.iPlayableServicePtr_subtitle,None,iPlayableServicePtr)
iPlayableServicePtr.audioDelay = new_instancemethod(_enigma.iPlayableServicePtr_audioDelay,None,iPlayableServicePtr)
iPlayableServicePtr.rdsDecoder = new_instancemethod(_enigma.iPlayableServicePtr_rdsDecoder,None,iPlayableServicePtr)
iPlayableServicePtr.stream = new_instancemethod(_enigma.iPlayableServicePtr_stream,None,iPlayableServicePtr)
iPlayableServicePtr.streamed = new_instancemethod(_enigma.iPlayableServicePtr_streamed,None,iPlayableServicePtr)
iPlayableServicePtr.keys = new_instancemethod(_enigma.iPlayableServicePtr_keys,None,iPlayableServicePtr)
iPlayableServicePtr.hbbtv = new_instancemethod(_enigma.iPlayableServicePtr_hbbtv,None,iPlayableServicePtr)
iPlayableServicePtr_swigregister = _enigma.iPlayableServicePtr_swigregister
iPlayableServicePtr_swigregister(iPlayableServicePtr)

class iRecordableService_ENUMS(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")
    __repr__ = _swig_repr
    evStart = _enigma.iRecordableService_ENUMS_evStart
    evEnd = _enigma.iRecordableService_ENUMS_evEnd
    evTunedIn = _enigma.iRecordableService_ENUMS_evTunedIn
    evTuneFailed = _enigma.iRecordableService_ENUMS_evTuneFailed
    evRecordRunning = _enigma.iRecordableService_ENUMS_evRecordRunning
    evRecordStopped = _enigma.iRecordableService_ENUMS_evRecordStopped
    evNewProgramInfo = _enigma.iRecordableService_ENUMS_evNewProgramInfo
    evRecordFailed = _enigma.iRecordableService_ENUMS_evRecordFailed
    evRecordWriteError = _enigma.iRecordableService_ENUMS_evRecordWriteError
    evNewEventInfo = _enigma.iRecordableService_ENUMS_evNewEventInfo
    NoError = _enigma.iRecordableService_ENUMS_NoError
    errOpenRecordFile = _enigma.iRecordableService_ENUMS_errOpenRecordFile
    errNoDemuxAvailable = _enigma.iRecordableService_ENUMS_errNoDemuxAvailable
    errNoTsRecorderAvailable = _enigma.iRecordableService_ENUMS_errNoTsRecorderAvailable
    errDiskFull = _enigma.iRecordableService_ENUMS_errDiskFull
    errTuneFailed = _enigma.iRecordableService_ENUMS_errTuneFailed
    errMisconfiguration = _enigma.iRecordableService_ENUMS_errMisconfiguration
    errNoResources = _enigma.iRecordableService_ENUMS_errNoResources
iRecordableService_ENUMS_swigregister = _enigma.iRecordableService_ENUMS_swigregister
iRecordableService_ENUMS_swigregister(iRecordableService_ENUMS)

iRecordableService = iRecordableService_ENUMS
class iRecordableServicePtr(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): 
        _enigma.iRecordableServicePtr_swiginit(self,_enigma.new_iRecordableServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iRecordableServicePtr
iRecordableServicePtr.__ref__ = new_instancemethod(_enigma.iRecordableServicePtr___ref__,None,iRecordableServicePtr)
iRecordableServicePtr.getPtrString = new_instancemethod(_enigma.iRecordableServicePtr_getPtrString,None,iRecordableServicePtr)
iRecordableServicePtr.__deref__ = new_instancemethod(_enigma.iRecordableServicePtr___deref__,None,iRecordableServicePtr)
iRecordableServicePtr.getError = new_instancemethod(_enigma.iRecordableServicePtr_getError,None,iRecordableServicePtr)
iRecordableServicePtr.prepare = new_instancemethod(_enigma.iRecordableServicePtr_prepare,None,iRecordableServicePtr)
iRecordableServicePtr.prepareStreaming = new_instancemethod(_enigma.iRecordableServicePtr_prepareStreaming,None,iRecordableServicePtr)
iRecordableServicePtr.start = new_instancemethod(_enigma.iRecordableServicePtr_start,None,iRecordableServicePtr)
iRecordableServicePtr.stop = new_instancemethod(_enigma.iRecordableServicePtr_stop,None,iRecordableServicePtr)
iRecordableServicePtr.frontendInfo = new_instancemethod(_enigma.iRecordableServicePtr_frontendInfo,None,iRecordableServicePtr)
iRecordableServicePtr.stream = new_instancemethod(_enigma.iRecordableServicePtr_stream,None,iRecordableServicePtr)
iRecordableServicePtr.subServices = new_instancemethod(_enigma.iRecordableServicePtr_subServices,None,iRecordableServicePtr)
iRecordableServicePtr_swigregister = _enigma.iRecordableServicePtr_swigregister
iRecordableServicePtr_swigregister(iRecordableServicePtr)


def New_iRecordableServicePtr(*args):
  return _enigma.New_iRecordableServicePtr(*args)
New_iRecordableServicePtr = _enigma.New_iRecordableServicePtr
class iServiceHandlerPtr(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): 
        _enigma.iServiceHandlerPtr_swiginit(self,_enigma.new_iServiceHandlerPtr(*args))
    __swig_destroy__ = _enigma.delete_iServiceHandlerPtr
iServiceHandlerPtr.__ref__ = new_instancemethod(_enigma.iServiceHandlerPtr___ref__,None,iServiceHandlerPtr)
iServiceHandlerPtr.getPtrString = new_instancemethod(_enigma.iServiceHandlerPtr_getPtrString,None,iServiceHandlerPtr)
iServiceHandlerPtr.__deref__ = new_instancemethod(_enigma.iServiceHandlerPtr___deref__,None,iServiceHandlerPtr)
iServiceHandlerPtr.play = new_instancemethod(_enigma.iServiceHandlerPtr_play,None,iServiceHandlerPtr)
iServiceHandlerPtr.record = new_instancemethod(_enigma.iServiceHandlerPtr_record,None,iServiceHandlerPtr)
iServiceHandlerPtr.list = new_instancemethod(_enigma.iServiceHandlerPtr_list,None,iServiceHandlerPtr)
iServiceHandlerPtr.info = new_instancemethod(_enigma.iServiceHandlerPtr_info,None,iServiceHandlerPtr)
iServiceHandlerPtr.offlineOperations = new_instancemethod(_enigma.iServiceHandlerPtr_offlineOperations,None,iServiceHandlerPtr)
iServiceHandlerPtr_swigregister = _enigma.iServiceHandlerPtr_swigregister
iServiceHandlerPtr_swigregister(iServiceHandlerPtr)

class eServiceCenter(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
    getInstance = staticmethod(_enigma.eServiceCenter_getInstance)
eServiceCenter_swigregister = _enigma.eServiceCenter_swigregister
eServiceCenter_swigregister(eServiceCenter)

def eServiceCenter_getInstance():
  return _enigma.eServiceCenter_getInstance()
eServiceCenter_getInstance = _enigma.eServiceCenter_getInstance

atUnknown = _enigma.atUnknown
atMPEG = _enigma.atMPEG
atMP3 = _enigma.atMP3
atAC3 = _enigma.atAC3
atDTS = _enigma.atDTS
atAAC = _enigma.atAAC
atPCM = _enigma.atPCM
atOGG = _enigma.atOGG
atFLAC = _enigma.atFLAC
atWMA = _enigma.atWMA
stUnknown = _enigma.stUnknown
stPlainText = _enigma.stPlainText
stSSA = _enigma.stSSA
stASS = _enigma.stASS
stSRT = _enigma.stSRT
stVOB = _enigma.stVOB
stPGS = _enigma.stPGS
ctNone = _enigma.ctNone
ctMPEGTS = _enigma.ctMPEGTS
ctMPEGPS = _enigma.ctMPEGPS
ctMKV = _enigma.ctMKV
ctAVI = _enigma.ctAVI
ctMP4 = _enigma.ctMP4
ctVCD = _enigma.ctVCD
ctCDA = _enigma.ctCDA
ctFLV = _enigma.ctFLV
ctWM = _enigma.ctWM
class eServiceMP3_ENUMS(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")
    __repr__ = _swig_repr
    evAudioDecodeError = _enigma.eServiceMP3_ENUMS_evAudioDecodeError
    evVideoDecodeError = _enigma.eServiceMP3_ENUMS_evVideoDecodeError
    evPluginError = _enigma.eServiceMP3_ENUMS_evPluginError
    evEmbeddedCoverArt = _enigma.eServiceMP3_ENUMS_evEmbeddedCoverArt
    evUpdatedBitrate = _enigma.eServiceMP3_ENUMS_evUpdatedBitrate
    evStreamingSrcError = _enigma.eServiceMP3_ENUMS_evStreamingSrcError
eServiceMP3_ENUMS_swigregister = _enigma.eServiceMP3_ENUMS_swigregister
eServiceMP3_ENUMS_swigregister(eServiceMP3_ENUMS)

eServiceMP3 = eServiceMP3_ENUMS
class ePythonMessagePump(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    recv_msg = _swig_property(_enigma.ePythonMessagePump_recv_msg_get, _enigma.ePythonMessagePump_recv_msg_set)
    def __init__(self): 
        _enigma.ePythonMessagePump_swiginit(self,_enigma.new_ePythonMessagePump())
    __swig_destroy__ = _enigma.delete_ePythonMessagePump
ePythonMessagePump.send = new_instancemethod(_enigma.ePythonMessagePump_send,None,ePythonMessagePump)
ePythonMessagePump.start = new_instancemethod(_enigma.ePythonMessagePump_start,None,ePythonMessagePump)
ePythonMessagePump.stop = new_instancemethod(_enigma.ePythonMessagePump_stop,None,ePythonMessagePump)
ePythonMessagePump_swigregister = _enigma.ePythonMessagePump_swigregister
ePythonMessagePump_swigregister(ePythonMessagePump)

class eTPM(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    DT_TPM_VERSION = _enigma.eTPM_DT_TPM_VERSION
    DT_SERIAL = _enigma.eTPM_DT_SERIAL
    DT_LEVEL2_CERT = _enigma.eTPM_DT_LEVEL2_CERT
    DT_LEVEL3_CERT = _enigma.eTPM_DT_LEVEL3_CERT
    DT_FAB_CA_CERT = _enigma.eTPM_DT_FAB_CA_CERT
    DT_DATABLOCK_SIGNED = _enigma.eTPM_DT_DATABLOCK_SIGNED
    APDU_READ = _enigma.eTPM_APDU_READ
    APDU_WRITE = _enigma.eTPM_APDU_WRITE
    def __init__(self): 
        _enigma.eTPM_swiginit(self,_enigma.new_eTPM())
    __swig_destroy__ = _enigma.delete_eTPM
    TPMD_DT_LEVEL2_CERT = _enigma.eTPM_TPMD_DT_LEVEL2_CERT
    TPMD_DT_LEVEL3_CERT = _enigma.eTPM_TPMD_DT_LEVEL3_CERT
eTPM.getCert = new_instancemethod(_enigma.eTPM_getCert,None,eTPM)
eTPM.challenge = new_instancemethod(_enigma.eTPM_challenge,None,eTPM)
eTPM.getData = new_instancemethod(_enigma.eTPM_getData,None,eTPM)
eTPM.apdu = new_instancemethod(_enigma.eTPM_apdu,None,eTPM)
eTPM.computeSignature = new_instancemethod(_enigma.eTPM_computeSignature,None,eTPM)
eTPM.appCert = new_instancemethod(_enigma.eTPM_appCert,None,eTPM)
eTPM_swigregister = _enigma.eTPM_swigregister
eTPM_swigregister(eTPM)

class ePythonConfigQuery(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")
    __repr__ = _swig_repr
    getQueryFuncSignal = staticmethod(_enigma.ePythonConfigQuery_getQueryFuncSignal)
ePythonConfigQuery_swigregister = _enigma.ePythonConfigQuery_swigregister
ePythonConfigQuery_swigregister(ePythonConfigQuery)

def ePythonConfigQuery_getQueryFuncSignal():
  return _enigma.ePythonConfigQuery_getQueryFuncSignal()
ePythonConfigQuery_getQueryFuncSignal = _enigma.ePythonConfigQuery_getQueryFuncSignal

class eRCInput(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")
    __repr__ = _swig_repr
    kmNone = _enigma.eRCInput_kmNone
    kmAscii = _enigma.eRCInput_kmAscii
    kmAll = _enigma.eRCInput_kmAll
    getInstance = staticmethod(_enigma.eRCInput_getInstance)
eRCInput.setKeyboardMode = new_instancemethod(_enigma.eRCInput_setKeyboardMode,None,eRCInput)
eRCInput.getKeyboardMode = new_instancemethod(_enigma.eRCInput_getKeyboardMode,None,eRCInput)
eRCInput.lock = new_instancemethod(_enigma.eRCInput_lock,None,eRCInput)
eRCInput.unlock = new_instancemethod(_enigma.eRCInput_unlock,None,eRCInput)
eRCInput.islocked = new_instancemethod(_enigma.eRCInput_islocked,None,eRCInput)
eRCInput_swigregister = _enigma.eRCInput_swigregister
eRCInput_swigregister(eRCInput)

def eRCInput_getInstance():
  return _enigma.eRCInput_getInstance()
eRCInput_getInstance = _enigma.eRCInput_getInstance

class fbClass(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.fbClass_getInstance)
fbClass.lock = new_instancemethod(_enigma.fbClass_lock,None,fbClass)
fbClass.unlock = new_instancemethod(_enigma.fbClass_unlock,None,fbClass)
fbClass.islocked = new_instancemethod(_enigma.fbClass_islocked,None,fbClass)
fbClass_swigregister = _enigma.fbClass_swigregister
fbClass_swigregister(fbClass)

def fbClass_getInstance():
  return _enigma.fbClass_getInstance()
fbClass_getInstance = _enigma.fbClass_getInstance

class fontRenderClass(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.fontRenderClass_getInstance)
fontRenderClass.getLineHeight = new_instancemethod(_enigma.fontRenderClass_getLineHeight,None,fontRenderClass)
fontRenderClass_swigregister = _enigma.fontRenderClass_swigregister
fontRenderClass_swigregister(fontRenderClass)

def fontRenderClass_getInstance():
  return _enigma.fontRenderClass_getInstance()
fontRenderClass_getInstance = _enigma.fontRenderClass_getInstance

__GPIXMAP_H_INSIDE__ = _enigma.__GPIXMAP_H_INSIDE__
class gPixmapPtr(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): 
        _enigma.gPixmapPtr_swiginit(self,_enigma.new_gPixmapPtr(*args))
    __swig_destroy__ = _enigma.delete_gPixmapPtr
gPixmapPtr.__ref__ = new_instancemethod(_enigma.gPixmapPtr___ref__,None,gPixmapPtr)
gPixmapPtr.getPtrString = new_instancemethod(_enigma.gPixmapPtr_getPtrString,None,gPixmapPtr)
gPixmapPtr.__deref__ = new_instancemethod(_enigma.gPixmapPtr___deref__,None,gPixmapPtr)
gPixmapPtr.size = new_instancemethod(_enigma.gPixmapPtr_size,None,gPixmapPtr)
gPixmapPtr.color = new_instancemethod(_enigma.gPixmapPtr_color,None,gPixmapPtr)
gPixmapPtr.colorCount = new_instancemethod(_enigma.gPixmapPtr_colorCount,None,gPixmapPtr)
gPixmapPtr.colorTable = new_instancemethod(_enigma.gPixmapPtr_colorTable,None,gPixmapPtr)
gPixmapPtr.setColor = new_instancemethod(_enigma.gPixmapPtr_setColor,None,gPixmapPtr)
gPixmapPtr.setColorCount = new_instancemethod(_enigma.gPixmapPtr_setColorCount,None,gPixmapPtr)
gPixmapPtr.setColorTable = new_instancemethod(_enigma.gPixmapPtr_setColorTable,None,gPixmapPtr)
gPixmapPtr.setScaleFilter = new_instancemethod(_enigma.gPixmapPtr_setScaleFilter,None,gPixmapPtr)
gPixmapPtr.scale = new_instancemethod(_enigma.gPixmapPtr_scale,None,gPixmapPtr)
gPixmapPtr.read = new_instancemethod(_enigma.gPixmapPtr_read,None,gPixmapPtr)
gPixmapPtr_swigregister = _enigma.gPixmapPtr_swigregister
gPixmapPtr_swigregister(gPixmapPtr)

class gMainDC(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): 
        _enigma.gMainDC_swiginit(self,_enigma.new_gMainDC(*args))
    __swig_destroy__ = _enigma.delete_gMainDC
    getInstance = staticmethod(_enigma.gMainDC_getInstance)
gMainDC.__ref__ = new_instancemethod(_enigma.gMainDC___ref__,None,gMainDC)
gMainDC.getPtrString = new_instancemethod(_enigma.gMainDC_getPtrString,None,gMainDC)
gMainDC.__deref__ = new_instancemethod(_enigma.gMainDC___deref__,None,gMainDC)
gMainDC.setResolution = new_instancemethod(_enigma.gMainDC_setResolution,None,gMainDC)
gMainDC_swigregister = _enigma.gMainDC_swigregister
gMainDC_swigregister(gMainDC)

def gMainDC_getInstance():
  return _enigma.gMainDC_getInstance()
gMainDC_getInstance = _enigma.gMainDC_getInstance

class ePoint(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): 
        _enigma.ePoint_swiginit(self,_enigma.new_ePoint(*args))
    __swig_destroy__ = _enigma.delete_ePoint
ePoint.isNull = new_instancemethod(_enigma.ePoint_isNull,None,ePoint)
ePoint.x = new_instancemethod(_enigma.ePoint_x,None,ePoint)
ePoint.y = new_instancemethod(_enigma.ePoint_y,None,ePoint)
ePoint.setX = new_instancemethod(_enigma.ePoint_setX,None,ePoint)
ePoint.setY = new_instancemethod(_enigma.ePoint_setY,None,ePoint)
ePoint.manhattanLength = new_instancemethod(_enigma.ePoint_manhattanLength,None,ePoint)
ePoint.rx = new_instancemethod(_enigma.ePoint_rx,None,ePoint)
ePoint.ry = new_instancemethod(_enigma.ePoint_ry,None,ePoint)
ePoint.__iadd__ = new_instancemethod(_enigma.ePoint___iadd__,None,ePoint)
ePoint.__isub__ = new_instancemethod(_enigma.ePoint___isub__,None,ePoint)
ePoint.__imul__ = new_instancemethod(_enigma.ePoint___imul__,None,ePoint)
ePoint.__idiv__ = new_instancemethod(_enigma.ePoint___idiv__,None,ePoint)
ePoint_swigregister = _enigma.ePoint_swigregister
ePoint_swigregister(ePoint)

class eRect(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): 
        _enigma.eRect_swiginit(self,_enigma.new_eRect(*args))
    emptyRect = staticmethod(_enigma.eRect_emptyRect)
    invalidRect = staticmethod(_enigma.eRect_invalidRect)
    __swig_destroy__ = _enigma.delete_eRect
eRect.empty = new_instancemethod(_enigma.eRect_empty,None,eRect)
eRect.valid = new_instancemethod(_enigma.eRect_valid,None,eRect)
eRect.normalize = new_instancemethod(_enigma.eRect_normalize,None,eRect)
eRect.left = new_instancemethod(_enigma.eRect_left,None,eRect)
eRect.top = new_instancemethod(_enigma.eRect_top,None,eRect)
eRect.right = new_instancemethod(_enigma.eRect_right,None,eRect)
eRect.bottom = new_instancemethod(_enigma.eRect_bottom,None,eRect)
eRect.rLeft = new_instancemethod(_enigma.eRect_rLeft,None,eRect)
eRect.rTop = new_instancemethod(_enigma.eRect_rTop,None,eRect)
eRect.rRight = new_instancemethod(_enigma.eRect_rRight,None,eRect)
eRect.rBottom = new_instancemethod(_enigma.eRect_rBottom,None,eRect)
eRect.x = new_instancemethod(_enigma.eRect_x,None,eRect)
eRect.y = new_instancemethod(_enigma.eRect_y,None,eRect)
eRect.setLeft = new_instancemethod(_enigma.eRect_setLeft,None,eRect)
eRect.setTop = new_instancemethod(_enigma.eRect_setTop,None,eRect)
eRect.setRight = new_instancemethod(_enigma.eRect_setRight,None,eRect)
eRect.setBottom = new_instancemethod(_enigma.eRect_setBottom,None,eRect)
eRect.setX = new_instancemethod(_enigma.eRect_setX,None,eRect)
eRect.setY = new_instancemethod(_enigma.eRect_setY,None,eRect)
eRect.topLeft = new_instancemethod(_enigma.eRect_topLeft,None,eRect)
eRect.bottomRight = new_instancemethod(_enigma.eRect_bottomRight,None,eRect)
eRect.topRight = new_instancemethod(_enigma.eRect_topRight,None,eRect)
eRect.bottomLeft = new_instancemethod(_enigma.eRect_bottomLeft,None,eRect)
eRect.topLeft1 = new_instancemethod(_enigma.eRect_topLeft1,None,eRect)
eRect.bottomRight1 = new_instancemethod(_enigma.eRect_bottomRight1,None,eRect)
eRect.topRight1 = new_instancemethod(_enigma.eRect_topRight1,None,eRect)
eRect.bottomLeft1 = new_instancemethod(_enigma.eRect_bottomLeft1,None,eRect)
eRect.center = new_instancemethod(_enigma.eRect_center,None,eRect)
eRect.rect = new_instancemethod(_enigma.eRect_rect,None,eRect)
eRect.coords = new_instancemethod(_enigma.eRect_coords,None,eRect)
eRect.moveTopLeft = new_instancemethod(_enigma.eRect_moveTopLeft,None,eRect)
eRect.moveBottomRight = new_instancemethod(_enigma.eRect_moveBottomRight,None,eRect)
eRect.moveTopRight = new_instancemethod(_enigma.eRect_moveTopRight,None,eRect)
eRect.moveBottomLeft = new_instancemethod(_enigma.eRect_moveBottomLeft,None,eRect)
eRect.moveCenter = new_instancemethod(_enigma.eRect_moveCenter,None,eRect)
eRect.moveBy = new_instancemethod(_enigma.eRect_moveBy,None,eRect)
eRect.setRect = new_instancemethod(_enigma.eRect_setRect,None,eRect)
eRect.setCoords = new_instancemethod(_enigma.eRect_setCoords,None,eRect)
eRect.size = new_instancemethod(_enigma.eRect_size,None,eRect)
eRect.width = new_instancemethod(_enigma.eRect_width,None,eRect)
eRect.height = new_instancemethod(_enigma.eRect_height,None,eRect)
eRect.setWidth = new_instancemethod(_enigma.eRect_setWidth,None,eRect)
eRect.setHeight = new_instancemethod(_enigma.eRect_setHeight,None,eRect)
eRect.setSize = new_instancemethod(_enigma.eRect_setSize,None,eRect)
eRect.setEmpty = new_instancemethod(_enigma.eRect_setEmpty,None,eRect)
eRect.__or__ = new_instancemethod(_enigma.eRect___or__,None,eRect)
eRect.__and__ = new_instancemethod(_enigma.eRect___and__,None,eRect)
eRect.__ior__ = new_instancemethod(_enigma.eRect___ior__,None,eRect)
eRect.__iand__ = new_instancemethod(_enigma.eRect___iand__,None,eRect)
eRect.contains = new_instancemethod(_enigma.eRect_contains,None,eRect)
eRect.unite = new_instancemethod(_enigma.eRect_unite,None,eRect)
eRect.intersect = new_instancemethod(_enigma.eRect_intersect,None,eRect)
eRect.intersects = new_instancemethod(_enigma.eRect_intersects,None,eRect)
eRect.scaleToCenterOf = new_instancemethod(_enigma.eRect_scaleToCenterOf,None,eRect)
eRect.scale = new_instancemethod(_enigma.eRect_scale,None,eRect)
eRect_swigregister = _enigma.eRect_swigregister
eRect_swigregister(eRect)

def eRect_emptyRect():
  return _enigma.eRect_emptyRect()
eRect_emptyRect = _enigma.eRect_emptyRect

def eRect_invalidRect():
  return _enigma.eRect_invalidRect()
eRect_invalidRect = _enigma.eRect_invalidRect

class eSize(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): 
        _enigma.eSize_swiginit(self,_enigma.new_eSize(*args))
    __swig_destroy__ = _enigma.delete_eSize
eSize.isNull = new_instancemethod(_enigma.eSize_isNull,None,eSize)
eSize.isEmpty = new_instancemethod(_enigma.eSize_isEmpty,None,eSize)
eSize.isValid = new_instancemethod(_enigma.eSize_isValid,None,eSize)
eSize.width = new_instancemethod(_enigma.eSize_width,None,eSize)
eSize.height = new_instancemethod(_enigma.eSize_height,None,eSize)
eSize.setWidth = new_instancemethod(_enigma.eSize_setWidth,None,eSize)
eSize.setHeight = new_instancemethod(_enigma.eSize_setHeight,None,eSize)
eSize.transpose = new_instancemethod(_enigma.eSize_transpose,None,eSize)
eSize.scale = new_instancemethod(_enigma.eSize_scale,None,eSize)
eSize.expandedTo = new_instancemethod(_enigma.eSize_expandedTo,None,eSize)
eSize.boundedTo = new_instancemethod(_enigma.eSize_boundedTo,None,eSize)
eSize.rwidth = new_instancemethod(_enigma.eSize_rwidth,None,eSize)
eSize.rheight = new_instancemethod(_enigma.eSize_rheight,None,eSize)
eSize.__iadd__ = new_instancemethod(_enigma.eSize___iadd__,None,eSize)
eSize.__isub__ = new_instancemethod(_enigma.eSize___isub__,None,eSize)
eSize.__imul__ = new_instancemethod(_enigma.eSize___imul__,None,eSize)
eSize.__idiv__ = new_instancemethod(_enigma.eSize___idiv__,None,eSize)
eSize_swigregister = _enigma.eSize_swigregister
eSize_swigregister(eSize)

class eMatrix(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): 
        _enigma.eMatrix_swiginit(self,_enigma.new_eMatrix(*args))
    __swig_destroy__ = _enigma.delete_eMatrix
eMatrix.__call__ = new_instancemethod(_enigma.eMatrix___call__,None,eMatrix)
eMatrix.__eq__ = new_instancemethod(_enigma.eMatrix___eq__,None,eMatrix)
eMatrix.__ne__ = new_instancemethod(_enigma.eMatrix___ne__,None,eMatrix)
eMatrix.__imul__ = new_instancemethod(_enigma.eMatrix___imul__,None,eMatrix)
eMatrix.__mul__ = new_instancemethod(_enigma.eMatrix___mul__,None,eMatrix)
eMatrix.__iadd__ = new_instancemethod(_enigma.eMatrix___iadd__,None,eMatrix)
eMatrix.__add__ = new_instancemethod(_enigma.eMatrix___add__,None,eMatrix)
eMatrix.__isub__ = new_instancemethod(_enigma.eMatrix___isub__,None,eMatrix)
eMatrix.__sub__ = new_instancemethod(_enigma.eMatrix___sub__,None,eMatrix)
eMatrix_swigregister = _enigma.eMatrix_swigregister
eMatrix_swigregister(eMatrix)

class eSquareMatrix(eMatrix):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NullMatrix = _enigma.eSquareMatrix_NullMatrix
    IdentityMatrix = _enigma.eSquareMatrix_IdentityMatrix
    def __init__(self, *args): 
        _enigma.eSquareMatrix_swiginit(self,_enigma.new_eSquareMatrix(*args))
    __swig_destroy__ = _enigma.delete_eSquareMatrix
eSquareMatrix_swigregister = _enigma.eSquareMatrix_swigregister
eSquareMatrix_swigregister(eSquareMatrix)

class eMatrix4x4(eSquareMatrix):
    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): 
        _enigma.eMatrix4x4_swiginit(self,_enigma.new_eMatrix4x4(*args))
    identity = staticmethod(_enigma.eMatrix4x4_identity)
    orthographic = staticmethod(_enigma.eMatrix4x4_orthographic)
    perspective = staticmethod(_enigma.eMatrix4x4_perspective)
    rotateX = staticmethod(_enigma.eMatrix4x4_rotateX)
    rotateY = staticmethod(_enigma.eMatrix4x4_rotateY)
    rotateZ = staticmethod(_enigma.eMatrix4x4_rotateZ)
    scale = staticmethod(_enigma.eMatrix4x4_scale)
    __swig_destroy__ = _enigma.delete_eMatrix4x4
eMatrix4x4.translate = new_instancemethod(_enigma.eMatrix4x4_translate,None,eMatrix4x4)
eMatrix4x4_swigregister = _enigma.eMatrix4x4_swigregister
eMatrix4x4_swigregister(eMatrix4x4)

def eMatrix4x4_identity():
  return _enigma.eMatrix4x4_identity()
eMatrix4x4_identity = _enigma.eMatrix4x4_identity

def eMatrix4x4_orthographic(*args):
  return _enigma.eMatrix4x4_orthographic(*args)
eMatrix4x4_orthographic = _enigma.eMatrix4x4_orthographic

def eMatrix4x4_perspective(*args):
  return _enigma.eMatrix4x4_perspective(*args)
eMatrix4x4_perspective = _enigma.eMatrix4x4_perspective

def eMatrix4x4_rotateX(*args):
  return _enigma.eMatrix4x4_rotateX(*args)
eMatrix4x4_rotateX = _enigma.eMatrix4x4_rotateX

def eMatrix4x4_rotateY(*args):
  return _enigma.eMatrix4x4_rotateY(*args)
eMatrix4x4_rotateY = _enigma.eMatrix4x4_rotateY

def eMatrix4x4_rotateZ(*args):
  return _enigma.eMatrix4x4_rotateZ(*args)
eMatrix4x4_rotateZ = _enigma.eMatrix4x4_rotateZ

def eMatrix4x4_scale(*args):
  return _enigma.eMatrix4x4_scale(*args)
eMatrix4x4_scale = _enigma.eMatrix4x4_scale

class gRGBA(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    r = _swig_property(_enigma.gRGBA_r_get, _enigma.gRGBA_r_set)
    g = _swig_property(_enigma.gRGBA_g_get, _enigma.gRGBA_g_set)
    b = _swig_property(_enigma.gRGBA_b_get, _enigma.gRGBA_b_set)
    a = _swig_property(_enigma.gRGBA_a_get, _enigma.gRGBA_a_set)
    def __init__(self, *args): 
        _enigma.gRGBA_swiginit(self,_enigma.new_gRGBA(*args))
    fromArgb = staticmethod(_enigma.gRGBA_fromArgb)
    premultiplyChannel = staticmethod(_enigma.gRGBA_premultiplyChannel)
    __swig_destroy__ = _enigma.delete_gRGBA
gRGBA.argb = new_instancemethod(_enigma.gRGBA_argb,None,gRGBA)
gRGBA.__lt__ = new_instancemethod(_enigma.gRGBA___lt__,None,gRGBA)
gRGBA.__eq__ = new_instancemethod(_enigma.gRGBA___eq__,None,gRGBA)
gRGBA.__ne__ = new_instancemethod(_enigma.gRGBA___ne__,None,gRGBA)
gRGBA.premultiplyAlpha = new_instancemethod(_enigma.gRGBA_premultiplyAlpha,None,gRGBA)
gRGBA.set = new_instancemethod(_enigma.gRGBA_set,None,gRGBA)
gRGBA.pixel = new_instancemethod(_enigma.gRGBA_pixel,None,gRGBA)
gRGBA.fromPixel = new_instancemethod(_enigma.gRGBA_fromPixel,None,gRGBA)
gRGBA_swigregister = _enigma.gRGBA_swigregister
gRGBA_swigregister(gRGBA)

def gRGBA_fromArgb(*args):
  return _enigma.gRGBA_fromArgb(*args)
gRGBA_fromArgb = _enigma.gRGBA_fromArgb

def gRGBA_premultiplyChannel(*args):
  return _enigma.gRGBA_premultiplyChannel(*args)
gRGBA_premultiplyChannel = _enigma.gRGBA_premultiplyChannel

class gRGB(gRGBA):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    a = _swig_property(_enigma.gRGB_a_get, _enigma.gRGB_a_set)
    def __init__(self, *args): 
        _enigma.gRGB_swiginit(self,_enigma.new_gRGB(*args))
    __swig_destroy__ = _enigma.delete_gRGB
gRGB.argb = new_instancemethod(_enigma.gRGB_argb,None,gRGB)
gRGB_swigregister = _enigma.gRGB_swigregister
gRGB_swigregister(gRGB)

DISABLED = _enigma.DISABLED
BILINEAR = _enigma.BILINEAR
ANISOTROPIC = _enigma.ANISOTROPIC
SHARP = _enigma.SHARP
SHARPER = _enigma.SHARPER
BLURRY = _enigma.BLURRY
ANTI_FLUTTER = _enigma.ANTI_FLUTTER
ANTI_FLUTTER_BLURRY = _enigma.ANTI_FLUTTER_BLURRY
ANTI_FLUTTER_SHARP = _enigma.ANTI_FLUTTER_SHARP
class iProgressInterpolator(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): 
        _enigma.iProgressInterpolator_swiginit(self,_enigma.new_iProgressInterpolator(*args))
    __swig_destroy__ = _enigma.delete_iProgressInterpolator
    def at(self, *args):
        """at(iProgressInterpolator self, float progress) -> float"""
        return _enigma.iProgressInterpolator_at(self, *args)

iProgressInterpolator.__ref__ = new_instancemethod(_enigma.iProgressInterpolator___ref__,None,iProgressInterpolator)
iProgressInterpolator.getPtrString = new_instancemethod(_enigma.iProgressInterpolator_getPtrString,None,iProgressInterpolator)
iProgressInterpolator.__deref__ = new_instancemethod(_enigma.iProgressInterpolator___deref__,None,iProgressInterpolator)
iProgressInterpolator.at = new_instancemethod(_enigma.iProgressInterpolator_at,None,iProgressInterpolator)
iProgressInterpolator_swigregister = _enigma.iProgressInterpolator_swigregister
iProgressInterpolator_swigregister(iProgressInterpolator)

class eLinearInterpolator(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): 
        _enigma.eLinearInterpolator_swiginit(self,_enigma.new_eLinearInterpolator(*args))
    __swig_destroy__ = _enigma.delete_eLinearInterpolator
    create = staticmethod(_enigma.eLinearInterpolator_create)
    def at(self, *args):
        """at(eLinearInterpolator self, float progress) -> float"""
        return _enigma.eLinearInterpolator_at(self, *args)

eLinearInterpolator.__ref__ = new_instancemethod(_enigma.eLinearInterpolator___ref__,None,eLinearInterpolator)
eLinearInterpolator.getPtrString = new_instancemethod(_enigma.eLinearInterpolator_getPtrString,None,eLinearInterpolator)
eLinearInterpolator.__deref__ = new_instancemethod(_enigma.eLinearInterpolator___deref__,None,eLinearInterpolator)
eLinearInterpolator.at = new_instancemethod(_enigma.eLinearInterpolator_at,None,eLinearInterpolator)
eLinearInterpolator_swigregister = _enigma.eLinearInterpolator_swigregister
eLinearInterpolator_swigregister(eLinearInterpolator)

def eLinearInterpolator_create():
  return _enigma.eLinearInterpolator_create()
eLinearInterpolator_create = _enigma.eLinearInterpolator_create

class eAcclerateInterpolator(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): 
        _enigma.eAcclerateInterpolator_swiginit(self,_enigma.new_eAcclerateInterpolator(*args))
    __swig_destroy__ = _enigma.delete_eAcclerateInterpolator
    create = staticmethod(_enigma.eAcclerateInterpolator_create)
    def at(self, *args):
        """at(eAcclerateInterpolator self, float progress) -> float"""
        return _enigma.eAcclerateInterpolator_at(self, *args)

eAcclerateInterpolator.__ref__ = new_instancemethod(_enigma.eAcclerateInterpolator___ref__,None,eAcclerateInterpolator)
eAcclerateInterpolator.getPtrString = new_instancemethod(_enigma.eAcclerateInterpolator_getPtrString,None,eAcclerateInterpolator)
eAcclerateInterpolator.__deref__ = new_instancemethod(_enigma.eAcclerateInterpolator___deref__,None,eAcclerateInterpolator)
eAcclerateInterpolator.at = new_instancemethod(_enigma.eAcclerateInterpolator_at,None,eAcclerateInterpolator)
eAcclerateInterpolator_swigregister = _enigma.eAcclerateInterpolator_swigregister
eAcclerateInterpolator_swigregister(eAcclerateInterpolator)

def eAcclerateInterpolator_create(factor=1.0):
  return _enigma.eAcclerateInterpolator_create(factor)
eAcclerateInterpolator_create = _enigma.eAcclerateInterpolator_create

class eDecelerateInterpolator(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): 
        _enigma.eDecelerateInterpolator_swiginit(self,_enigma.new_eDecelerateInterpolator(*args))
    __swig_destroy__ = _enigma.delete_eDecelerateInterpolator
    create = staticmethod(_enigma.eDecelerateInterpolator_create)
    def at(self, *args):
        """at(eDecelerateInterpolator self, float progress) -> float"""
        return _enigma.eDecelerateInterpolator_at(self, *args)

eDecelerateInterpolator.__ref__ = new_instancemethod(_enigma.eDecelerateInterpolator___ref__,None,eDecelerateInterpolator)
eDecelerateInterpolator.getPtrString = new_instancemethod(_enigma.eDecelerateInterpolator_getPtrString,None,eDecelerateInterpolator)
eDecelerateInterpolator.__deref__ = new_instancemethod(_enigma.eDecelerateInterpolator___deref__,None,eDecelerateInterpolator)
eDecelerateInterpolator.at = new_instancemethod(_enigma.eDecelerateInterpolator_at,None,eDecelerateInterpolator)
eDecelerateInterpolator_swigregister = _enigma.eDecelerateInterpolator_swigregister
eDecelerateInterpolator_swigregister(eDecelerateInterpolator)

def eDecelerateInterpolator_create(factor=1.0):
  return _enigma.eDecelerateInterpolator_create(factor)
eDecelerateInterpolator_create = _enigma.eDecelerateInterpolator_create

class eOvershootInterpolator(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): 
        _enigma.eOvershootInterpolator_swiginit(self,_enigma.new_eOvershootInterpolator(*args))
    __swig_destroy__ = _enigma.delete_eOvershootInterpolator
    create = staticmethod(_enigma.eOvershootInterpolator_create)
    def at(self, *args):
        """at(eOvershootInterpolator self, float progress) -> float"""
        return _enigma.eOvershootInterpolator_at(self, *args)

eOvershootInterpolator.__ref__ = new_instancemethod(_enigma.eOvershootInterpolator___ref__,None,eOvershootInterpolator)
eOvershootInterpolator.getPtrString = new_instancemethod(_enigma.eOvershootInterpolator_getPtrString,None,eOvershootInterpolator)
eOvershootInterpolator.__deref__ = new_instancemethod(_enigma.eOvershootInterpolator___deref__,None,eOvershootInterpolator)
eOvershootInterpolator.at = new_instancemethod(_enigma.eOvershootInterpolator_at,None,eOvershootInterpolator)
eOvershootInterpolator_swigregister = _enigma.eOvershootInterpolator_swigregister
eOvershootInterpolator_swigregister(eOvershootInterpolator)

def eOvershootInterpolator_create(tension=2.0):
  return _enigma.eOvershootInterpolator_create(tension)
eOvershootInterpolator_create = _enigma.eOvershootInterpolator_create

class eBounceInterpolator(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): 
        _enigma.eBounceInterpolator_swiginit(self,_enigma.new_eBounceInterpolator(*args))
    __swig_destroy__ = _enigma.delete_eBounceInterpolator
    create = staticmethod(_enigma.eBounceInterpolator_create)
    def at(self, *args):
        """at(eBounceInterpolator self, float progress) -> float"""
        return _enigma.eBounceInterpolator_at(self, *args)

eBounceInterpolator.__ref__ = new_instancemethod(_enigma.eBounceInterpolator___ref__,None,eBounceInterpolator)
eBounceInterpolator.getPtrString = new_instancemethod(_enigma.eBounceInterpolator_getPtrString,None,eBounceInterpolator)
eBounceInterpolator.__deref__ = new_instancemethod(_enigma.eBounceInterpolator___deref__,None,eBounceInterpolator)
eBounceInterpolator.at = new_instancemethod(_enigma.eBounceInterpolator_at,None,eBounceInterpolator)
eBounceInterpolator_swigregister = _enigma.eBounceInterpolator_swigregister
eBounceInterpolator_swigregister(eBounceInterpolator)

def eBounceInterpolator_create():
  return _enigma.eBounceInterpolator_create()
eBounceInterpolator_create = _enigma.eBounceInterpolator_create

class eWidgetAnimationFloat(iObject):
    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 reset(self, reversed=False):
        """
        reset(eWidgetAnimationFloat self, bool reversed=False)
        reset(eWidgetAnimationFloat self)
        """
        return _enigma.eWidgetAnimationFloat_reset(self, reversed)

    def getDuration(self):
        """getDuration(eWidgetAnimationFloat self) -> int64_t"""
        return _enigma.eWidgetAnimationFloat_getDuration(self)

    def setDuration(self, *args):
        """setDuration(eWidgetAnimationFloat self, int64_t ms)"""
        return _enigma.eWidgetAnimationFloat_setDuration(self, *args)

    def getFromValue(self):
        """getFromValue(eWidgetAnimationFloat self) -> float"""
        return _enigma.eWidgetAnimationFloat_getFromValue(self)

    def setFromValue(self, *args):
        """setFromValue(eWidgetAnimationFloat self, float value)"""
        return _enigma.eWidgetAnimationFloat_setFromValue(self, *args)

    def getToValue(self):
        """getToValue(eWidgetAnimationFloat self) -> float"""
        return _enigma.eWidgetAnimationFloat_getToValue(self)

    def setToValue(self, *args):
        """setToValue(eWidgetAnimationFloat self, float value)"""
        return _enigma.eWidgetAnimationFloat_setToValue(self, *args)

    def copy(self):
        """copy(eWidgetAnimationFloat self) -> eWidgetAnimationFloat"""
        return _enigma.eWidgetAnimationFloat_copy(self)

eWidgetAnimationFloat.reset = new_instancemethod(_enigma.eWidgetAnimationFloat_reset,None,eWidgetAnimationFloat)
eWidgetAnimationFloat.getDuration = new_instancemethod(_enigma.eWidgetAnimationFloat_getDuration,None,eWidgetAnimationFloat)
eWidgetAnimationFloat.setDuration = new_instancemethod(_enigma.eWidgetAnimationFloat_setDuration,None,eWidgetAnimationFloat)
eWidgetAnimationFloat.getFromValue = new_instancemethod(_enigma.eWidgetAnimationFloat_getFromValue,None,eWidgetAnimationFloat)
eWidgetAnimationFloat.setFromValue = new_instancemethod(_enigma.eWidgetAnimationFloat_setFromValue,None,eWidgetAnimationFloat)
eWidgetAnimationFloat.getToValue = new_instancemethod(_enigma.eWidgetAnimationFloat_getToValue,None,eWidgetAnimationFloat)
eWidgetAnimationFloat.setToValue = new_instancemethod(_enigma.eWidgetAnimationFloat_setToValue,None,eWidgetAnimationFloat)
eWidgetAnimationFloat.copy = new_instancemethod(_enigma.eWidgetAnimationFloat_copy,None,eWidgetAnimationFloat)
eWidgetAnimationFloat_swigregister = _enigma.eWidgetAnimationFloat_swigregister
eWidgetAnimationFloat_swigregister(eWidgetAnimationFloat)

class eFloatAnimation(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): 
        _enigma.eFloatAnimation_swiginit(self,_enigma.new_eFloatAnimation(*args))
    __swig_destroy__ = _enigma.delete_eFloatAnimation
    create = staticmethod(_enigma.eFloatAnimation_create)
eFloatAnimation.__ref__ = new_instancemethod(_enigma.eFloatAnimation___ref__,None,eFloatAnimation)
eFloatAnimation.getPtrString = new_instancemethod(_enigma.eFloatAnimation_getPtrString,None,eFloatAnimation)
eFloatAnimation.__deref__ = new_instancemethod(_enigma.eFloatAnimation___deref__,None,eFloatAnimation)
eFloatAnimation_swigregister = _enigma.eFloatAnimation_swigregister
eFloatAnimation_swigregister(eFloatAnimation)

def eFloatAnimation_create(*args):
  return _enigma.eFloatAnimation_create(*args)
eFloatAnimation_create = _enigma.eFloatAnimation_create

class eWidgetAnimationPoint(iObject):
    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 reset(self, reversed=False):
        """
        reset(eWidgetAnimationPoint self, bool reversed=False)
        reset(eWidgetAnimationPoint self)
        """
        return _enigma.eWidgetAnimationPoint_reset(self, reversed)

    def getDuration(self):
        """getDuration(eWidgetAnimationPoint self) -> int64_t"""
        return _enigma.eWidgetAnimationPoint_getDuration(self)

    def setDuration(self, *args):
        """setDuration(eWidgetAnimationPoint self, int64_t ms)"""
        return _enigma.eWidgetAnimationPoint_setDuration(self, *args)

    def getFromValue(self):
        """getFromValue(eWidgetAnimationPoint self) -> ePoint"""
        return _enigma.eWidgetAnimationPoint_getFromValue(self)

    def setFromValue(self, *args):
        """setFromValue(eWidgetAnimationPoint self, ePoint value)"""
        return _enigma.eWidgetAnimationPoint_setFromValue(self, *args)

    def getToValue(self):
        """getToValue(eWidgetAnimationPoint self) -> ePoint"""
        return _enigma.eWidgetAnimationPoint_getToValue(self)

    def setToValue(self, *args):
        """setToValue(eWidgetAnimationPoint self, ePoint value)"""
        return _enigma.eWidgetAnimationPoint_setToValue(self, *args)

    def copy(self):
        """copy(eWidgetAnimationPoint self) -> eWidgetAnimationPoint"""
        return _enigma.eWidgetAnimationPoint_copy(self)

eWidgetAnimationPoint.reset = new_instancemethod(_enigma.eWidgetAnimationPoint_reset,None,eWidgetAnimationPoint)
eWidgetAnimationPoint.getDuration = new_instancemethod(_enigma.eWidgetAnimationPoint_getDuration,None,eWidgetAnimationPoint)
eWidgetAnimationPoint.setDuration = new_instancemethod(_enigma.eWidgetAnimationPoint_setDuration,None,eWidgetAnimationPoint)
eWidgetAnimationPoint.getFromValue = new_instancemethod(_enigma.eWidgetAnimationPoint_getFromValue,None,eWidgetAnimationPoint)
eWidgetAnimationPoint.setFromValue = new_instancemethod(_enigma.eWidgetAnimationPoint_setFromValue,None,eWidgetAnimationPoint)
eWidgetAnimationPoint.getToValue = new_instancemethod(_enigma.eWidgetAnimationPoint_getToValue,None,eWidgetAnimationPoint)
eWidgetAnimationPoint.setToValue = new_instancemethod(_enigma.eWidgetAnimationPoint_setToValue,None,eWidgetAnimationPoint)
eWidgetAnimationPoint.copy = new_instancemethod(_enigma.eWidgetAnimationPoint_copy,None,eWidgetAnimationPoint)
eWidgetAnimationPoint_swigregister = _enigma.eWidgetAnimationPoint_swigregister
eWidgetAnimationPoint_swigregister(eWidgetAnimationPoint)

class ePointAnimation(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): 
        _enigma.ePointAnimation_swiginit(self,_enigma.new_ePointAnimation(*args))
    __swig_destroy__ = _enigma.delete_ePointAnimation
    create = staticmethod(_enigma.ePointAnimation_create)
    def at(self, *args):
        """at(ePointAnimation self, int64_t ms) -> ePoint"""
        return _enigma.ePointAnimation_at(self, *args)

    def animateX(self):
        """animateX(ePointAnimation self)"""
        return _enigma.ePointAnimation_animateX(self)

    def animateY(self):
        """animateY(ePointAnimation self)"""
        return _enigma.ePointAnimation_animateY(self)

    def animateXY(self):
        """animateXY(ePointAnimation self)"""
        return _enigma.ePointAnimation_animateXY(self)

ePointAnimation.__ref__ = new_instancemethod(_enigma.ePointAnimation___ref__,None,ePointAnimation)
ePointAnimation.getPtrString = new_instancemethod(_enigma.ePointAnimation_getPtrString,None,ePointAnimation)
ePointAnimation.__deref__ = new_instancemethod(_enigma.ePointAnimation___deref__,None,ePointAnimation)
ePointAnimation.at = new_instancemethod(_enigma.ePointAnimation_at,None,ePointAnimation)
ePointAnimation.animateX = new_instancemethod(_enigma.ePointAnimation_animateX,None,ePointAnimation)
ePointAnimation.animateY = new_instancemethod(_enigma.ePointAnimation_animateY,None,ePointAnimation)
ePointAnimation.animateXY = new_instancemethod(_enigma.ePointAnimation_animateXY,None,ePointAnimation)
ePointAnimation_swigregister = _enigma.ePointAnimation_swigregister
ePointAnimation_swigregister(ePointAnimation)

def ePointAnimation_create(*args):
  return _enigma.ePointAnimation_create(*args)
ePointAnimation_create = _enigma.ePointAnimation_create

class eWidgetAnimationSize(iObject):
    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 reset(self, reversed=False):
        """
        reset(eWidgetAnimationSize self, bool reversed=False)
        reset(eWidgetAnimationSize self)
        """
        return _enigma.eWidgetAnimationSize_reset(self, reversed)

    def getDuration(self):
        """getDuration(eWidgetAnimationSize self) -> int64_t"""
        return _enigma.eWidgetAnimationSize_getDuration(self)

    def setDuration(self, *args):
        """setDuration(eWidgetAnimationSize self, int64_t ms)"""
        return _enigma.eWidgetAnimationSize_setDuration(self, *args)

    def getFromValue(self):
        """getFromValue(eWidgetAnimationSize self) -> eSize"""
        return _enigma.eWidgetAnimationSize_getFromValue(self)

    def setFromValue(self, *args):
        """setFromValue(eWidgetAnimationSize self, eSize value)"""
        return _enigma.eWidgetAnimationSize_setFromValue(self, *args)

    def getToValue(self):
        """getToValue(eWidgetAnimationSize self) -> eSize"""
        return _enigma.eWidgetAnimationSize_getToValue(self)

    def setToValue(self, *args):
        """setToValue(eWidgetAnimationSize self, eSize value)"""
        return _enigma.eWidgetAnimationSize_setToValue(self, *args)

    def copy(self):
        """copy(eWidgetAnimationSize self) -> eWidgetAnimationSize"""
        return _enigma.eWidgetAnimationSize_copy(self)

eWidgetAnimationSize.reset = new_instancemethod(_enigma.eWidgetAnimationSize_reset,None,eWidgetAnimationSize)
eWidgetAnimationSize.getDuration = new_instancemethod(_enigma.eWidgetAnimationSize_getDuration,None,eWidgetAnimationSize)
eWidgetAnimationSize.setDuration = new_instancemethod(_enigma.eWidgetAnimationSize_setDuration,None,eWidgetAnimationSize)
eWidgetAnimationSize.getFromValue = new_instancemethod(_enigma.eWidgetAnimationSize_getFromValue,None,eWidgetAnimationSize)
eWidgetAnimationSize.setFromValue = new_instancemethod(_enigma.eWidgetAnimationSize_setFromValue,None,eWidgetAnimationSize)
eWidgetAnimationSize.getToValue = new_instancemethod(_enigma.eWidgetAnimationSize_getToValue,None,eWidgetAnimationSize)
eWidgetAnimationSize.setToValue = new_instancemethod(_enigma.eWidgetAnimationSize_setToValue,None,eWidgetAnimationSize)
eWidgetAnimationSize.copy = new_instancemethod(_enigma.eWidgetAnimationSize_copy,None,eWidgetAnimationSize)
eWidgetAnimationSize_swigregister = _enigma.eWidgetAnimationSize_swigregister
eWidgetAnimationSize_swigregister(eWidgetAnimationSize)

class eSizeAnimation(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): 
        _enigma.eSizeAnimation_swiginit(self,_enigma.new_eSizeAnimation(*args))
    __swig_destroy__ = _enigma.delete_eSizeAnimation
    create = staticmethod(_enigma.eSizeAnimation_create)
eSizeAnimation.__ref__ = new_instancemethod(_enigma.eSizeAnimation___ref__,None,eSizeAnimation)
eSizeAnimation.getPtrString = new_instancemethod(_enigma.eSizeAnimation_getPtrString,None,eSizeAnimation)
eSizeAnimation.__deref__ = new_instancemethod(_enigma.eSizeAnimation___deref__,None,eSizeAnimation)
eSizeAnimation_swigregister = _enigma.eSizeAnimation_swigregister
eSizeAnimation_swigregister(eSizeAnimation)

def eSizeAnimation_create(*args):
  return _enigma.eSizeAnimation_create(*args)
eSizeAnimation_create = _enigma.eSizeAnimation_create

class eWidgetAnimationMatrix(iObject):
    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 reset(self, reversed=False):
        """
        reset(eWidgetAnimationMatrix self, bool reversed=False)
        reset(eWidgetAnimationMatrix self)
        """
        return _enigma.eWidgetAnimationMatrix_reset(self, reversed)

    def getDuration(self):
        """getDuration(eWidgetAnimationMatrix self) -> int64_t"""
        return _enigma.eWidgetAnimationMatrix_getDuration(self)

    def setDuration(self, *args):
        """setDuration(eWidgetAnimationMatrix self, int64_t ms)"""
        return _enigma.eWidgetAnimationMatrix_setDuration(self, *args)

    def getFromValue(self):
        """getFromValue(eWidgetAnimationMatrix self) -> eMatrix4x4"""
        return _enigma.eWidgetAnimationMatrix_getFromValue(self)

    def setFromValue(self, *args):
        """setFromValue(eWidgetAnimationMatrix self, eMatrix4x4 value)"""
        return _enigma.eWidgetAnimationMatrix_setFromValue(self, *args)

    def getToValue(self):
        """getToValue(eWidgetAnimationMatrix self) -> eMatrix4x4"""
        return _enigma.eWidgetAnimationMatrix_getToValue(self)

    def setToValue(self, *args):
        """setToValue(eWidgetAnimationMatrix self, eMatrix4x4 value)"""
        return _enigma.eWidgetAnimationMatrix_setToValue(self, *args)

    def copy(self):
        """copy(eWidgetAnimationMatrix self) -> eWidgetAnimationMatrix"""
        return _enigma.eWidgetAnimationMatrix_copy(self)

eWidgetAnimationMatrix.reset = new_instancemethod(_enigma.eWidgetAnimationMatrix_reset,None,eWidgetAnimationMatrix)
eWidgetAnimationMatrix.getDuration = new_instancemethod(_enigma.eWidgetAnimationMatrix_getDuration,None,eWidgetAnimationMatrix)
eWidgetAnimationMatrix.setDuration = new_instancemethod(_enigma.eWidgetAnimationMatrix_setDuration,None,eWidgetAnimationMatrix)
eWidgetAnimationMatrix.getFromValue = new_instancemethod(_enigma.eWidgetAnimationMatrix_getFromValue,None,eWidgetAnimationMatrix)
eWidgetAnimationMatrix.setFromValue = new_instancemethod(_enigma.eWidgetAnimationMatrix_setFromValue,None,eWidgetAnimationMatrix)
eWidgetAnimationMatrix.getToValue = new_instancemethod(_enigma.eWidgetAnimationMatrix_getToValue,None,eWidgetAnimationMatrix)
eWidgetAnimationMatrix.setToValue = new_instancemethod(_enigma.eWidgetAnimationMatrix_setToValue,None,eWidgetAnimationMatrix)
eWidgetAnimationMatrix.copy = new_instancemethod(_enigma.eWidgetAnimationMatrix_copy,None,eWidgetAnimationMatrix)
eWidgetAnimationMatrix_swigregister = _enigma.eWidgetAnimationMatrix_swigregister
eWidgetAnimationMatrix_swigregister(eWidgetAnimationMatrix)

class eMatrixAnimation(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): 
        _enigma.eMatrixAnimation_swiginit(self,_enigma.new_eMatrixAnimation(*args))
    __swig_destroy__ = _enigma.delete_eMatrixAnimation
    create = staticmethod(_enigma.eMatrixAnimation_create)
eMatrixAnimation.__ref__ = new_instancemethod(_enigma.eMatrixAnimation___ref__,None,eMatrixAnimation)
eMatrixAnimation.getPtrString = new_instancemethod(_enigma.eMatrixAnimation_getPtrString,None,eMatrixAnimation)
eMatrixAnimation.__deref__ = new_instancemethod(_enigma.eMatrixAnimation___deref__,None,eMatrixAnimation)
eMatrixAnimation_swigregister = _enigma.eMatrixAnimation_swigregister
eMatrixAnimation_swigregister(eMatrixAnimation)

def eMatrixAnimation_create(*args):
  return _enigma.eMatrixAnimation_create(*args)
eMatrixAnimation_create = _enigma.eMatrixAnimation_create

class eWidgetAnimationSet(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): 
        _enigma.eWidgetAnimationSet_swiginit(self,_enigma.new_eWidgetAnimationSet(*args))
    __swig_destroy__ = _enigma.delete_eWidgetAnimationSet
    def isValid(self):
        """isValid(eWidgetAnimationSet self) -> bool"""
        return _enigma.eWidgetAnimationSet_isValid(self)

    def setAlphaAnimation(self, *args):
        """setAlphaAnimation(eWidgetAnimationSet self, eFloatAnimation alpha)"""
        return _enigma.eWidgetAnimationSet_setAlphaAnimation(self, *args)

    def setAlphaReverseAnimation(self, *args):
        """setAlphaReverseAnimation(eWidgetAnimationSet self, eFloatAnimation alpha)"""
        return _enigma.eWidgetAnimationSet_setAlphaReverseAnimation(self, *args)

    def setPositionAnimation(self, *args):
        """setPositionAnimation(eWidgetAnimationSet self, ePointAnimation position)"""
        return _enigma.eWidgetAnimationSet_setPositionAnimation(self, *args)

    def setPositionReverseAnimation(self, *args):
        """setPositionReverseAnimation(eWidgetAnimationSet self, ePointAnimation position)"""
        return _enigma.eWidgetAnimationSet_setPositionReverseAnimation(self, *args)

    def setSizeAnimation(self, *args):
        """setSizeAnimation(eWidgetAnimationSet self, eSizeAnimation size)"""
        return _enigma.eWidgetAnimationSet_setSizeAnimation(self, *args)

    def setSizeReverseAnimation(self, *args):
        """setSizeReverseAnimation(eWidgetAnimationSet self, eSizeAnimation size)"""
        return _enigma.eWidgetAnimationSet_setSizeReverseAnimation(self, *args)

    def setPerspectiveAnimation(self, *args):
        """setPerspectiveAnimation(eWidgetAnimationSet self, eMatrixAnimation perspective)"""
        return _enigma.eWidgetAnimationSet_setPerspectiveAnimation(self, *args)

    def setPerspectiveReverseAnimation(self, *args):
        """setPerspectiveReverseAnimation(eWidgetAnimationSet self, eMatrixAnimation perspective)"""
        return _enigma.eWidgetAnimationSet_setPerspectiveReverseAnimation(self, *args)

eWidgetAnimationSet.__ref__ = new_instancemethod(_enigma.eWidgetAnimationSet___ref__,None,eWidgetAnimationSet)
eWidgetAnimationSet.getPtrString = new_instancemethod(_enigma.eWidgetAnimationSet_getPtrString,None,eWidgetAnimationSet)
eWidgetAnimationSet.__deref__ = new_instancemethod(_enigma.eWidgetAnimationSet___deref__,None,eWidgetAnimationSet)
eWidgetAnimationSet.isValid = new_instancemethod(_enigma.eWidgetAnimationSet_isValid,None,eWidgetAnimationSet)
eWidgetAnimationSet.setAlphaAnimation = new_instancemethod(_enigma.eWidgetAnimationSet_setAlphaAnimation,None,eWidgetAnimationSet)
eWidgetAnimationSet.setAlphaReverseAnimation = new_instancemethod(_enigma.eWidgetAnimationSet_setAlphaReverseAnimation,None,eWidgetAnimationSet)
eWidgetAnimationSet.setPositionAnimation = new_instancemethod(_enigma.eWidgetAnimationSet_setPositionAnimation,None,eWidgetAnimationSet)
eWidgetAnimationSet.setPositionReverseAnimation = new_instancemethod(_enigma.eWidgetAnimationSet_setPositionReverseAnimation,None,eWidgetAnimationSet)
eWidgetAnimationSet.setSizeAnimation = new_instancemethod(_enigma.eWidgetAnimationSet_setSizeAnimation,None,eWidgetAnimationSet)
eWidgetAnimationSet.setSizeReverseAnimation = new_instancemethod(_enigma.eWidgetAnimationSet_setSizeReverseAnimation,None,eWidgetAnimationSet)
eWidgetAnimationSet.setPerspectiveAnimation = new_instancemethod(_enigma.eWidgetAnimationSet_setPerspectiveAnimation,None,eWidgetAnimationSet)
eWidgetAnimationSet.setPerspectiveReverseAnimation = new_instancemethod(_enigma.eWidgetAnimationSet_setPerspectiveReverseAnimation,None,eWidgetAnimationSet)
eWidgetAnimationSet_swigregister = _enigma.eWidgetAnimationSet_swigregister
eWidgetAnimationSet_swigregister(eWidgetAnimationSet)

class eWindowAnimationSet(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): 
        _enigma.eWindowAnimationSet_swiginit(self,_enigma.new_eWindowAnimationSet(*args))
    __swig_destroy__ = _enigma.delete_eWindowAnimationSet
    create = staticmethod(_enigma.eWindowAnimationSet_create)
    def isInternal(self):
        """isInternal(eWindowAnimationSet self) -> bool"""
        return _enigma.eWindowAnimationSet_isInternal(self)

    def getKey(self):
        """getKey(eWindowAnimationSet self) -> std::string"""
        return _enigma.eWindowAnimationSet_getKey(self)

    def getName(self):
        """getName(eWindowAnimationSet self) -> std::string"""
        return _enigma.eWindowAnimationSet_getName(self)

    def getAlpha(self):
        """getAlpha(eWindowAnimationSet self) -> eFloatAnimation"""
        return _enigma.eWindowAnimationSet_getAlpha(self)

    def getAlphaReverse(self):
        """getAlphaReverse(eWindowAnimationSet self) -> eFloatAnimation"""
        return _enigma.eWindowAnimationSet_getAlphaReverse(self)

    def getPos(self):
        """getPos(eWindowAnimationSet self) -> ePointAnimation"""
        return _enigma.eWindowAnimationSet_getPos(self)

    def getPosReverse(self):
        """getPosReverse(eWindowAnimationSet self) -> ePointAnimation"""
        return _enigma.eWindowAnimationSet_getPosReverse(self)

    def getSize(self):
        """getSize(eWindowAnimationSet self) -> eSizeAnimation"""
        return _enigma.eWindowAnimationSet_getSize(self)

    def getSizeReverse(self):
        """getSizeReverse(eWindowAnimationSet self) -> eSizeAnimation"""
        return _enigma.eWindowAnimationSet_getSizeReverse(self)

    def getMatrix(self):
        """getMatrix(eWindowAnimationSet self) -> eMatrixAnimation"""
        return _enigma.eWindowAnimationSet_getMatrix(self)

    def getMatrixReverse(self):
        """getMatrixReverse(eWindowAnimationSet self) -> eMatrixAnimation"""
        return _enigma.eWindowAnimationSet_getMatrixReverse(self)

    def setInternal(self, *args):
        """setInternal(eWindowAnimationSet self, bool internal)"""
        return _enigma.eWindowAnimationSet_setInternal(self, *args)

    def setKey(self, *args):
        """setKey(eWindowAnimationSet self, std::string const & key)"""
        return _enigma.eWindowAnimationSet_setKey(self, *args)

    def setName(self, *args):
        """setName(eWindowAnimationSet self, std::string const & name)"""
        return _enigma.eWindowAnimationSet_setName(self, *args)

    def setAlpha(self, *args):
        """setAlpha(eWindowAnimationSet self, eFloatAnimation alpha)"""
        return _enigma.eWindowAnimationSet_setAlpha(self, *args)

    def setAlphaReverse(self, *args):
        """setAlphaReverse(eWindowAnimationSet self, eFloatAnimation alpha)"""
        return _enigma.eWindowAnimationSet_setAlphaReverse(self, *args)

    def setPos(self, *args):
        """setPos(eWindowAnimationSet self, ePointAnimation pos)"""
        return _enigma.eWindowAnimationSet_setPos(self, *args)

    def setPosReverse(self, *args):
        """setPosReverse(eWindowAnimationSet self, ePointAnimation pos)"""
        return _enigma.eWindowAnimationSet_setPosReverse(self, *args)

    def setSize(self, *args):
        """setSize(eWindowAnimationSet self, eSizeAnimation size)"""
        return _enigma.eWindowAnimationSet_setSize(self, *args)

    def setSizeReverse(self, *args):
        """setSizeReverse(eWindowAnimationSet self, eSizeAnimation size)"""
        return _enigma.eWindowAnimationSet_setSizeReverse(self, *args)

    def setMatrix(self, *args):
        """setMatrix(eWindowAnimationSet self, eMatrixAnimation matrix)"""
        return _enigma.eWindowAnimationSet_setMatrix(self, *args)

    def setMatrixReverse(self, *args):
        """setMatrixReverse(eWindowAnimationSet self, eMatrixAnimation matrix)"""
        return _enigma.eWindowAnimationSet_setMatrixReverse(self, *args)

eWindowAnimationSet.__ref__ = new_instancemethod(_enigma.eWindowAnimationSet___ref__,None,eWindowAnimationSet)
eWindowAnimationSet.getPtrString = new_instancemethod(_enigma.eWindowAnimationSet_getPtrString,None,eWindowAnimationSet)
eWindowAnimationSet.__deref__ = new_instancemethod(_enigma.eWindowAnimationSet___deref__,None,eWindowAnimationSet)
eWindowAnimationSet.isInternal = new_instancemethod(_enigma.eWindowAnimationSet_isInternal,None,eWindowAnimationSet)
eWindowAnimationSet.getKey = new_instancemethod(_enigma.eWindowAnimationSet_getKey,None,eWindowAnimationSet)
eWindowAnimationSet.getName = new_instancemethod(_enigma.eWindowAnimationSet_getName,None,eWindowAnimationSet)
eWindowAnimationSet.getAlpha = new_instancemethod(_enigma.eWindowAnimationSet_getAlpha,None,eWindowAnimationSet)
eWindowAnimationSet.getAlphaReverse = new_instancemethod(_enigma.eWindowAnimationSet_getAlphaReverse,None,eWindowAnimationSet)
eWindowAnimationSet.getPos = new_instancemethod(_enigma.eWindowAnimationSet_getPos,None,eWindowAnimationSet)
eWindowAnimationSet.getPosReverse = new_instancemethod(_enigma.eWindowAnimationSet_getPosReverse,None,eWindowAnimationSet)
eWindowAnimationSet.getSize = new_instancemethod(_enigma.eWindowAnimationSet_getSize,None,eWindowAnimationSet)
eWindowAnimationSet.getSizeReverse = new_instancemethod(_enigma.eWindowAnimationSet_getSizeReverse,None,eWindowAnimationSet)
eWindowAnimationSet.getMatrix = new_instancemethod(_enigma.eWindowAnimationSet_getMatrix,None,eWindowAnimationSet)
eWindowAnimationSet.getMatrixReverse = new_instancemethod(_enigma.eWindowAnimationSet_getMatrixReverse,None,eWindowAnimationSet)
eWindowAnimationSet.setInternal = new_instancemethod(_enigma.eWindowAnimationSet_setInternal,None,eWindowAnimationSet)
eWindowAnimationSet.setKey = new_instancemethod(_enigma.eWindowAnimationSet_setKey,None,eWindowAnimationSet)
eWindowAnimationSet.setName = new_instancemethod(_enigma.eWindowAnimationSet_setName,None,eWindowAnimationSet)
eWindowAnimationSet.setAlpha = new_instancemethod(_enigma.eWindowAnimationSet_setAlpha,None,eWindowAnimationSet)
eWindowAnimationSet.setAlphaReverse = new_instancemethod(_enigma.eWindowAnimationSet_setAlphaReverse,None,eWindowAnimationSet)
eWindowAnimationSet.setPos = new_instancemethod(_enigma.eWindowAnimationSet_setPos,None,eWindowAnimationSet)
eWindowAnimationSet.setPosReverse = new_instancemethod(_enigma.eWindowAnimationSet_setPosReverse,None,eWindowAnimationSet)
eWindowAnimationSet.setSize = new_instancemethod(_enigma.eWindowAnimationSet_setSize,None,eWindowAnimationSet)
eWindowAnimationSet.setSizeReverse = new_instancemethod(_enigma.eWindowAnimationSet_setSizeReverse,None,eWindowAnimationSet)
eWindowAnimationSet.setMatrix = new_instancemethod(_enigma.eWindowAnimationSet_setMatrix,None,eWindowAnimationSet)
eWindowAnimationSet.setMatrixReverse = new_instancemethod(_enigma.eWindowAnimationSet_setMatrixReverse,None,eWindowAnimationSet)
eWindowAnimationSet_swigregister = _enigma.eWindowAnimationSet_swigregister
eWindowAnimationSet_swigregister(eWindowAnimationSet)

def eWindowAnimationSet_create():
  return _enigma.eWindowAnimationSet_create()
eWindowAnimationSet_create = _enigma.eWindowAnimationSet_create

class eWindowAnimationManager(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): 
        _enigma.eWindowAnimationManager_swiginit(self,_enigma.new_eWindowAnimationManager(*args))
    __swig_destroy__ = _enigma.delete_eWindowAnimationManager
    KEY_DISABLED = _enigma.eWindowAnimationManager_KEY_DISABLED
    setAnimationSet = staticmethod(_enigma.eWindowAnimationManager_setAnimationSet)
    getAnimationSet = staticmethod(_enigma.eWindowAnimationManager_getAnimationSet)
    getAnimations = staticmethod(_enigma.eWindowAnimationManager_getAnimations)
    setDefault = staticmethod(_enigma.eWindowAnimationManager_setDefault)
    setAnimationsEnabled = staticmethod(_enigma.eWindowAnimationManager_setAnimationsEnabled)
    isAnimationsEnabled = staticmethod(_enigma.eWindowAnimationManager_isAnimationsEnabled)
    defaultAnimationChanged = _swig_property(_enigma.eWindowAnimationManager_defaultAnimationChanged_get, _enigma.eWindowAnimationManager_defaultAnimationChanged_set)
eWindowAnimationManager.__ref__ = new_instancemethod(_enigma.eWindowAnimationManager___ref__,None,eWindowAnimationManager)
eWindowAnimationManager.getPtrString = new_instancemethod(_enigma.eWindowAnimationManager_getPtrString,None,eWindowAnimationManager)
eWindowAnimationManager.__deref__ = new_instancemethod(_enigma.eWindowAnimationManager___deref__,None,eWindowAnimationManager)
eWindowAnimationManager_swigregister = _enigma.eWindowAnimationManager_swigregister
eWindowAnimationManager_swigregister(eWindowAnimationManager)

def eWindowAnimationManager_setAnimationSet(*args):
  return _enigma.eWindowAnimationManager_setAnimationSet(*args)
eWindowAnimationManager_setAnimationSet = _enigma.eWindowAnimationManager_setAnimationSet

def eWindowAnimationManager_getAnimationSet(*args):
  return _enigma.eWindowAnimationManager_getAnimationSet(*args)
eWindowAnimationManager_getAnimationSet = _enigma.eWindowAnimationManager_getAnimationSet

def eWindowAnimationManager_getAnimations():
  return _enigma.eWindowAnimationManager_getAnimations()
eWindowAnimationManager_getAnimations = _enigma.eWindowAnimationManager_getAnimations

def eWindowAnimationManager_setDefault(*args):
  return _enigma.eWindowAnimationManager_setDefault(*args)
eWindowAnimationManager_setDefault = _enigma.eWindowAnimationManager_setDefault

def eWindowAnimationManager_setAnimationsEnabled(*args):
  return _enigma.eWindowAnimationManager_setAnimationsEnabled(*args)
eWindowAnimationManager_setAnimationsEnabled = _enigma.eWindowAnimationManager_setAnimationsEnabled

def eWindowAnimationManager_isAnimationsEnabled():
  return _enigma.eWindowAnimationManager_isAnimationsEnabled()
eWindowAnimationManager_isAnimationsEnabled = _enigma.eWindowAnimationManager_isAnimationsEnabled

class eWidget(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): 
        _enigma.eWidget_swiginit(self,_enigma.new_eWidget(*args))
    __swig_destroy__ = _enigma.delete_eWidget
    hideAnimationFinished = _swig_property(_enigma.eWidget_hideAnimationFinished_get, _enigma.eWidget_hideAnimationFinished_set)
    showAnimationFinished = _swig_property(_enigma.eWidget_showAnimationFinished_get, _enigma.eWidget_showAnimationFinished_set)
    m_clip_region = _swig_property(_enigma.eWidget_m_clip_region_get, _enigma.eWidget_m_clip_region_set)
    m_visible_region = _swig_property(_enigma.eWidget_m_visible_region_get, _enigma.eWidget_m_visible_region_set)
    m_visible_with_childs = _swig_property(_enigma.eWidget_m_visible_with_childs_get, _enigma.eWidget_m_visible_with_childs_set)
    evtPaint = _enigma.eWidget_evtPaint
    evtKey = _enigma.eWidget_evtKey
    evtChangedPosition = _enigma.eWidget_evtChangedPosition
    evtChangedSize = _enigma.eWidget_evtChangedSize
    evtParentChangedPosition = _enigma.eWidget_evtParentChangedPosition
    evtParentVisibilityChanged = _enigma.eWidget_evtParentVisibilityChanged
    evtWillChangePosition = _enigma.eWidget_evtWillChangePosition
    evtWillChangeSize = _enigma.eWidget_evtWillChangeSize
    evtAction = _enigma.eWidget_evtAction
    evtFocusGot = _enigma.eWidget_evtFocusGot
    evtFocusLost = _enigma.eWidget_evtFocusLost
    evtUserWidget = _enigma.eWidget_evtUserWidget
eWidget.move = new_instancemethod(_enigma.eWidget_move,None,eWidget)
eWidget.resize = new_instancemethod(_enigma.eWidget_resize,None,eWidget)
eWidget.position = new_instancemethod(_enigma.eWidget_position,None,eWidget)
eWidget.size = new_instancemethod(_enigma.eWidget_size,None,eWidget)
eWidget.csize = new_instancemethod(_enigma.eWidget_csize,None,eWidget)
eWidget.parentSize = new_instancemethod(_enigma.eWidget_parentSize,None,eWidget)
eWidget.parentCsize = new_instancemethod(_enigma.eWidget_parentCsize,None,eWidget)
eWidget.invalidate = new_instancemethod(_enigma.eWidget_invalidate,None,eWidget)
eWidget.invalidateForAnimation = new_instancemethod(_enigma.eWidget_invalidateForAnimation,None,eWidget)
eWidget.child = new_instancemethod(_enigma.eWidget_child,None,eWidget)
eWidget.show = new_instancemethod(_enigma.eWidget_show,None,eWidget)
eWidget.hide = new_instancemethod(_enigma.eWidget_hide,None,eWidget)
eWidget.doHide = new_instancemethod(_enigma.eWidget_doHide,None,eWidget)
eWidget.destruct = new_instancemethod(_enigma.eWidget_destruct,None,eWidget)
eWidget.getStyle = new_instancemethod(_enigma.eWidget_getStyle,None,eWidget)
eWidget.setStyle = new_instancemethod(_enigma.eWidget_setStyle,None,eWidget)
eWidget.setBackgroundColor = new_instancemethod(_enigma.eWidget_setBackgroundColor,None,eWidget)
eWidget.clearBackgroundColor = new_instancemethod(_enigma.eWidget_clearBackgroundColor,None,eWidget)
eWidget.setZPosition = new_instancemethod(_enigma.eWidget_setZPosition,None,eWidget)
eWidget.setTransparent = new_instancemethod(_enigma.eWidget_setTransparent,None,eWidget)
eWidget.isVisible = new_instancemethod(_enigma.eWidget_isVisible,None,eWidget)
eWidget.isFading = new_instancemethod(_enigma.eWidget_isFading,None,eWidget)
eWidget.disable = new_instancemethod(_enigma.eWidget_disable,None,eWidget)
eWidget.enable = new_instancemethod(_enigma.eWidget_enable,None,eWidget)
eWidget.isEnabled = new_instancemethod(_enigma.eWidget_isEnabled,None,eWidget)
eWidget.onAnimationFinished = new_instancemethod(_enigma.eWidget_onAnimationFinished,None,eWidget)
eWidget.signalHideAnimationFinished = new_instancemethod(_enigma.eWidget_signalHideAnimationFinished,None,eWidget)
eWidget.canAnimate = new_instancemethod(_enigma.eWidget_canAnimate,None,eWidget)
eWidget.isFinishedAnimating = new_instancemethod(_enigma.eWidget_isFinishedAnimating,None,eWidget)
eWidget.setParentTitle = new_instancemethod(_enigma.eWidget_setParentTitle,None,eWidget)
eWidget.setPulsate = new_instancemethod(_enigma.eWidget_setPulsate,None,eWidget)
eWidget.isTransparent = new_instancemethod(_enigma.eWidget_isTransparent,None,eWidget)
eWidget.getAbsolutePosition = new_instancemethod(_enigma.eWidget_getAbsolutePosition,None,eWidget)
eWidget.event = new_instancemethod(_enigma.eWidget_event,None,eWidget)
eWidget.setFocus = new_instancemethod(_enigma.eWidget_setFocus,None,eWidget)
eWidget.setPositionNotifyChild = new_instancemethod(_enigma.eWidget_setPositionNotifyChild,None,eWidget)
eWidget.notifyShowHide = new_instancemethod(_enigma.eWidget_notifyShowHide,None,eWidget)
eWidget_swigregister = _enigma.eWidget_swigregister
eWidget_swigregister(eWidget)


def getDesktop(*args):
  return _enigma.getDesktop(*args)
getDesktop = _enigma.getDesktop
class eLabel(eWidget):
    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): 
        _enigma.eLabel_swiginit(self,_enigma.new_eLabel(*args))
    alignLeft = _enigma.eLabel_alignLeft
    alignTop = _enigma.eLabel_alignTop
    alignCenter = _enigma.eLabel_alignCenter
    alignRight = _enigma.eLabel_alignRight
    alignBottom = _enigma.eLabel_alignBottom
    alignBlock = _enigma.eLabel_alignBlock
    __swig_destroy__ = _enigma.delete_eLabel
eLabel.setText = new_instancemethod(_enigma.eLabel_setText,None,eLabel)
eLabel.setMarkedPos = new_instancemethod(_enigma.eLabel_setMarkedPos,None,eLabel)
eLabel.setFont = new_instancemethod(_enigma.eLabel_setFont,None,eLabel)
eLabel.getFont = new_instancemethod(_enigma.eLabel_getFont,None,eLabel)
eLabel.setVAlign = new_instancemethod(_enigma.eLabel_setVAlign,None,eLabel)
eLabel.setHAlign = new_instancemethod(_enigma.eLabel_setHAlign,None,eLabel)
eLabel.setForegroundColor = new_instancemethod(_enigma.eLabel_setForegroundColor,None,eLabel)
eLabel.setShadowColor = new_instancemethod(_enigma.eLabel_setShadowColor,None,eLabel)
eLabel.setShadowOffset = new_instancemethod(_enigma.eLabel_setShadowOffset,None,eLabel)
eLabel.setNoWrap = new_instancemethod(_enigma.eLabel_setNoWrap,None,eLabel)
eLabel.clearForegroundColor = new_instancemethod(_enigma.eLabel_clearForegroundColor,None,eLabel)
eLabel.calculateSize = new_instancemethod(_enigma.eLabel_calculateSize,None,eLabel)
eLabel_swigregister = _enigma.eLabel_swigregister
eLabel_swigregister(eLabel)

class ePixmap(eWidget):
    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): 
        _enigma.ePixmap_swiginit(self,_enigma.new_ePixmap(*args))
    FMT_GIF = _enigma.ePixmap_FMT_GIF
    FMT_JPEG = _enigma.ePixmap_FMT_JPEG
    FMT_PNG = _enigma.ePixmap_FMT_PNG
    __swig_destroy__ = _enigma.delete_ePixmap
ePixmap.setPixmap = new_instancemethod(_enigma.ePixmap_setPixmap,None,ePixmap)
ePixmap.setPixmapFromFile = new_instancemethod(_enigma.ePixmap_setPixmapFromFile,None,ePixmap)
ePixmap.setPixmapFromUI = new_instancemethod(_enigma.ePixmap_setPixmapFromUI,None,ePixmap)
ePixmap.setPixmapFromScreen = new_instancemethod(_enigma.ePixmap_setPixmapFromScreen,None,ePixmap)
ePixmap.setPixmapFromVideo = new_instancemethod(_enigma.ePixmap_setPixmapFromVideo,None,ePixmap)
ePixmap.setAlphatest = new_instancemethod(_enigma.ePixmap_setAlphatest,None,ePixmap)
ePixmap.setScale = new_instancemethod(_enigma.ePixmap_setScale,None,ePixmap)
ePixmap.setScaleDest = new_instancemethod(_enigma.ePixmap_setScaleDest,None,ePixmap)
ePixmap.setBorderWidth = new_instancemethod(_enigma.ePixmap_setBorderWidth,None,ePixmap)
ePixmap.setBorderColor = new_instancemethod(_enigma.ePixmap_setBorderColor,None,ePixmap)
ePixmap.save = new_instancemethod(_enigma.ePixmap_save,None,ePixmap)
ePixmap_swigregister = _enigma.ePixmap_swigregister
ePixmap_swigregister(ePixmap)

class eCanvas(ePixmap):
    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): 
        _enigma.eCanvas_swiginit(self,_enigma.new_eCanvas(*args))
    __swig_destroy__ = _enigma.delete_eCanvas
eCanvas.setSize = new_instancemethod(_enigma.eCanvas_setSize,None,eCanvas)
eCanvas.clear = new_instancemethod(_enigma.eCanvas_clear,None,eCanvas)
eCanvas.fillRect = new_instancemethod(_enigma.eCanvas_fillRect,None,eCanvas)
eCanvas.writeText = new_instancemethod(_enigma.eCanvas_writeText,None,eCanvas)
eCanvas_swigregister = _enigma.eCanvas_swigregister
eCanvas_swigregister(eCanvas)

class eButton(eLabel):
    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): 
        _enigma.eButton_swiginit(self,_enigma.new_eButton(*args))
    selected = _swig_property(_enigma.eButton_selected_get, _enigma.eButton_selected_set)
    __swig_destroy__ = _enigma.delete_eButton
eButton.push = new_instancemethod(_enigma.eButton_push,None,eButton)
eButton_swigregister = _enigma.eButton_swigregister
eButton_swigregister(eButton)

class eWindow(eWidget):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(eWindow self, eWidgetDesktop desktop, int z=0) -> eWindow
        __init__(eWindow self, eWidgetDesktop desktop) -> eWindow
        """
        _enigma.eWindow_swiginit(self,_enigma.new_eWindow(*args))
    __swig_destroy__ = _enigma.delete_eWindow
    def setShowHideAnimation(self, *args):
        """setShowHideAnimation(eWindow self, std::string const & key) -> bool"""
        return _enigma.eWindow_setShowHideAnimation(self, *args)

    def neverAnimate(self):
        """neverAnimate(eWindow self)"""
        return _enigma.eWindow_neverAnimate(self)

    def setTitle(self, *args):
        """setTitle(eWindow self, std::string const & string)"""
        return _enigma.eWindow_setTitle(self, *args)

    def getTitle(self):
        """getTitle(eWindow self) -> std::string"""
        return _enigma.eWindow_getTitle(self)

    wfNoBorder = _enigma.eWindow_wfNoBorder
    def setBackgroundColor(self, *args):
        """setBackgroundColor(eWindow self, gRGB col)"""
        return _enigma.eWindow_setBackgroundColor(self, *args)

    def setFlag(self, *args):
        """setFlag(eWindow self, int flags)"""
        return _enigma.eWindow_setFlag(self, *args)

    def clearFlag(self, *args):
        """clearFlag(eWindow self, int flags)"""
        return _enigma.eWindow_clearFlag(self, *args)

eWindow.setShowHideAnimation = new_instancemethod(_enigma.eWindow_setShowHideAnimation,None,eWindow)
eWindow.neverAnimate = new_instancemethod(_enigma.eWindow_neverAnimate,None,eWindow)
eWindow.setTitle = new_instancemethod(_enigma.eWindow_setTitle,None,eWindow)
eWindow.getTitle = new_instancemethod(_enigma.eWindow_getTitle,None,eWindow)
eWindow.setBackgroundColor = new_instancemethod(_enigma.eWindow_setBackgroundColor,None,eWindow)
eWindow.setFlag = new_instancemethod(_enigma.eWindow_setFlag,None,eWindow)
eWindow.clearFlag = new_instancemethod(_enigma.eWindow_clearFlag,None,eWindow)
eWindow_swigregister = _enigma.eWindow_swigregister
eWindow_swigregister(eWindow)

class eSlider(eWidget):
    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): 
        _enigma.eSlider_swiginit(self,_enigma.new_eSlider(*args))
    orHorizontal = _enigma.eSlider_orHorizontal
    orVertical = _enigma.eSlider_orVertical
    __swig_destroy__ = _enigma.delete_eSlider
eSlider.setValue = new_instancemethod(_enigma.eSlider_setValue,None,eSlider)
eSlider.setStartEnd = new_instancemethod(_enigma.eSlider_setStartEnd,None,eSlider)
eSlider.setRange = new_instancemethod(_enigma.eSlider_setRange,None,eSlider)
eSlider.setOrientation = new_instancemethod(_enigma.eSlider_setOrientation,None,eSlider)
eSlider.setBorderWidth = new_instancemethod(_enigma.eSlider_setBorderWidth,None,eSlider)
eSlider.setBorderColor = new_instancemethod(_enigma.eSlider_setBorderColor,None,eSlider)
eSlider.setPixmap = new_instancemethod(_enigma.eSlider_setPixmap,None,eSlider)
eSlider.setValuePixmap = new_instancemethod(_enigma.eSlider_setValuePixmap,None,eSlider)
eSlider.setBackgroundPixmap = new_instancemethod(_enigma.eSlider_setBackgroundPixmap,None,eSlider)
eSlider.setBackgroundPixmapTopHeight = new_instancemethod(_enigma.eSlider_setBackgroundPixmapTopHeight,None,eSlider)
eSlider.setBackgroundPixmapBottomHeight = new_instancemethod(_enigma.eSlider_setBackgroundPixmapBottomHeight,None,eSlider)
eSlider.setValuePixmapTopHeight = new_instancemethod(_enigma.eSlider_setValuePixmapTopHeight,None,eSlider)
eSlider.setValuePixmapBottomHeight = new_instancemethod(_enigma.eSlider_setValuePixmapBottomHeight,None,eSlider)
eSlider.clearProperties = new_instancemethod(_enigma.eSlider_clearProperties,None,eSlider)
eSlider.updateScrollLabelProperties = new_instancemethod(_enigma.eSlider_updateScrollLabelProperties,None,eSlider)
eSlider_swigregister = _enigma.eSlider_swigregister
eSlider_swigregister(eSlider)

class ePositionGauge(eWidget):
    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): 
        _enigma.ePositionGauge_swiginit(self,_enigma.new_ePositionGauge(*args))
    __swig_destroy__ = _enigma.delete_ePositionGauge
ePositionGauge.setLength = new_instancemethod(_enigma.ePositionGauge_setLength,None,ePositionGauge)
ePositionGauge.setPosition = new_instancemethod(_enigma.ePositionGauge_setPosition,None,ePositionGauge)
ePositionGauge.setInColor = new_instancemethod(_enigma.ePositionGauge_setInColor,None,ePositionGauge)
ePositionGauge.setPointer = new_instancemethod(_enigma.ePositionGauge_setPointer,None,ePositionGauge)
ePositionGauge.setInOutList = new_instancemethod(_enigma.ePositionGauge_setInOutList,None,ePositionGauge)
ePositionGauge.setForegroundColor = new_instancemethod(_enigma.ePositionGauge_setForegroundColor,None,ePositionGauge)
ePositionGauge.enableSeekPointer = new_instancemethod(_enigma.ePositionGauge_enableSeekPointer,None,ePositionGauge)
ePositionGauge.setSeekPosition = new_instancemethod(_enigma.ePositionGauge_setSeekPosition,None,ePositionGauge)
ePositionGauge_swigregister = _enigma.ePositionGauge_swigregister
ePositionGauge_swigregister(ePositionGauge)

TIME_PER_FRAME = _enigma.TIME_PER_FRAME
class eWidgetDesktop(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): 
        _enigma.eWidgetDesktop_swiginit(self,_enigma.new_eWidgetDesktop(*args))
    __swig_destroy__ = _enigma.delete_eWidgetDesktop
    cmImmediate = _enigma.eWidgetDesktop_cmImmediate
    cmBuffered = _enigma.eWidgetDesktop_cmBuffered
eWidgetDesktop.addRootWidget = new_instancemethod(_enigma.eWidgetDesktop_addRootWidget,None,eWidgetDesktop)
eWidgetDesktop.removeRootWidget = new_instancemethod(_enigma.eWidgetDesktop_removeRootWidget,None,eWidgetDesktop)
eWidgetDesktop.movedWidget = new_instancemethod(_enigma.eWidgetDesktop_movedWidget,None,eWidgetDesktop)
eWidgetDesktop.recalcClipRegions = new_instancemethod(_enigma.eWidgetDesktop_recalcClipRegions,None,eWidgetDesktop)
eWidgetDesktop.invalidate = new_instancemethod(_enigma.eWidgetDesktop_invalidate,None,eWidgetDesktop)
eWidgetDesktop.paint = new_instancemethod(_enigma.eWidgetDesktop_paint,None,eWidgetDesktop)
eWidgetDesktop.setDC = new_instancemethod(_enigma.eWidgetDesktop_setDC,None,eWidgetDesktop)
eWidgetDesktop.setBackgroundColor = new_instancemethod(_enigma.eWidgetDesktop_setBackgroundColor,None,eWidgetDesktop)
eWidgetDesktop.setPalette = new_instancemethod(_enigma.eWidgetDesktop_setPalette,None,eWidgetDesktop)
eWidgetDesktop.setRedrawTask = new_instancemethod(_enigma.eWidgetDesktop_setRedrawTask,None,eWidgetDesktop)
eWidgetDesktop.makeCompatiblePixmap = new_instancemethod(_enigma.eWidgetDesktop_makeCompatiblePixmap,None,eWidgetDesktop)
eWidgetDesktop.pixelFormat = new_instancemethod(_enigma.eWidgetDesktop_pixelFormat,None,eWidgetDesktop)
eWidgetDesktop.compositionMode = new_instancemethod(_enigma.eWidgetDesktop_compositionMode,None,eWidgetDesktop)
eWidgetDesktop.setCompositionMode = new_instancemethod(_enigma.eWidgetDesktop_setCompositionMode,None,eWidgetDesktop)
eWidgetDesktop.getStyleID = new_instancemethod(_enigma.eWidgetDesktop_getStyleID,None,eWidgetDesktop)
eWidgetDesktop.setStyleID = new_instancemethod(_enigma.eWidgetDesktop_setStyleID,None,eWidgetDesktop)
eWidgetDesktop.resize = new_instancemethod(_enigma.eWidgetDesktop_resize,None,eWidgetDesktop)
eWidgetDesktop.size = new_instancemethod(_enigma.eWidgetDesktop_size,None,eWidgetDesktop)
eWidgetDesktop.isDimmable = new_instancemethod(_enigma.eWidgetDesktop_isDimmable,None,eWidgetDesktop)
eWidgetDesktop.createScreenshot = new_instancemethod(_enigma.eWidgetDesktop_createScreenshot,None,eWidgetDesktop)
eWidgetDesktop_swigregister = _enigma.eWidgetDesktop_swigregister
eWidgetDesktop_swigregister(eWidgetDesktop)

class iListboxContent(iObject):
    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__ = _enigma.delete_iListboxContent
iListboxContent_swigregister = _enigma.iListboxContent_swigregister
iListboxContent_swigregister(iListboxContent)

class eListbox(eWidget):
    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): 
        _enigma.eListbox_swiginit(self,_enigma.new_eListbox(*args))
    __swig_destroy__ = _enigma.delete_eListbox
    setWrapAroundDefault = staticmethod(_enigma.eListbox_setWrapAroundDefault)
    selectionChanged = _swig_property(_enigma.eListbox_selectionChanged_get, _enigma.eListbox_selectionChanged_set)
    showOnDemand = _enigma.eListbox_showOnDemand
    showAlways = _enigma.eListbox_showAlways
    showNever = _enigma.eListbox_showNever
    moveUp = _enigma.eListbox_moveUp
    moveDown = _enigma.eListbox_moveDown
    moveTop = _enigma.eListbox_moveTop
    moveEnd = _enigma.eListbox_moveEnd
    pageUp = _enigma.eListbox_pageUp
    pageDown = _enigma.eListbox_pageDown
    justCheck = _enigma.eListbox_justCheck
eListbox.setScrollbarMode = new_instancemethod(_enigma.eListbox_setScrollbarMode,None,eListbox)
eListbox.setWrapAround = new_instancemethod(_enigma.eListbox_setWrapAround,None,eListbox)
eListbox.setBacklogMode = new_instancemethod(_enigma.eListbox_setBacklogMode,None,eListbox)
eListbox.setContent = new_instancemethod(_enigma.eListbox_setContent,None,eListbox)
eListbox.getCurrentIndex = new_instancemethod(_enigma.eListbox_getCurrentIndex,None,eListbox)
eListbox.moveSelection = new_instancemethod(_enigma.eListbox_moveSelection,None,eListbox)
eListbox.moveSelectionTo = new_instancemethod(_enigma.eListbox_moveSelectionTo,None,eListbox)
eListbox.moveToEnd = new_instancemethod(_enigma.eListbox_moveToEnd,None,eListbox)
eListbox.atBegin = new_instancemethod(_enigma.eListbox_atBegin,None,eListbox)
eListbox.atEnd = new_instancemethod(_enigma.eListbox_atEnd,None,eListbox)
eListbox.setItemHeight = new_instancemethod(_enigma.eListbox_setItemHeight,None,eListbox)
eListbox.setSelectionEnable = new_instancemethod(_enigma.eListbox_setSelectionEnable,None,eListbox)
eListbox.setBackgroundColor = new_instancemethod(_enigma.eListbox_setBackgroundColor,None,eListbox)
eListbox.setBackgroundColorSelected = new_instancemethod(_enigma.eListbox_setBackgroundColorSelected,None,eListbox)
eListbox.setForegroundColor = new_instancemethod(_enigma.eListbox_setForegroundColor,None,eListbox)
eListbox.setForegroundColorSelected = new_instancemethod(_enigma.eListbox_setForegroundColorSelected,None,eListbox)
eListbox.setBackgroundPicture = new_instancemethod(_enigma.eListbox_setBackgroundPicture,None,eListbox)
eListbox.setSelectionPicture = new_instancemethod(_enigma.eListbox_setSelectionPicture,None,eListbox)
eListbox.setScrollbarSliderPicture = new_instancemethod(_enigma.eListbox_setScrollbarSliderPicture,None,eListbox)
eListbox.setScrollbarSliderBackgroundPicture = new_instancemethod(_enigma.eListbox_setScrollbarSliderBackgroundPicture,None,eListbox)
eListbox.setScrollbarValuePicture = new_instancemethod(_enigma.eListbox_setScrollbarValuePicture,None,eListbox)
eListbox.setScrollbarSliderBorderWidth = new_instancemethod(_enigma.eListbox_setScrollbarSliderBorderWidth,None,eListbox)
eListbox.setScrollbarWidth = new_instancemethod(_enigma.eListbox_setScrollbarWidth,None,eListbox)
eListbox.setScrollbarBackgroundPixmapTopHeight = new_instancemethod(_enigma.eListbox_setScrollbarBackgroundPixmapTopHeight,None,eListbox)
eListbox.setScrollbarBackgroundPixmapBottomHeight = new_instancemethod(_enigma.eListbox_setScrollbarBackgroundPixmapBottomHeight,None,eListbox)
eListbox.setScrollbarValuePixmapTopHeight = new_instancemethod(_enigma.eListbox_setScrollbarValuePixmapTopHeight,None,eListbox)
eListbox.setScrollbarValuePixmapBottomHeight = new_instancemethod(_enigma.eListbox_setScrollbarValuePixmapBottomHeight,None,eListbox)
eListbox.resetScrollbarProperties = new_instancemethod(_enigma.eListbox_resetScrollbarProperties,None,eListbox)
eListbox_swigregister = _enigma.eListbox_swigregister
eListbox_swigregister(eListbox)

def eListbox_setWrapAroundDefault(*args):
  return _enigma.eListbox_setWrapAroundDefault(*args)
eListbox_setWrapAroundDefault = _enigma.eListbox_setWrapAroundDefault

class eListboxPythonStringContent(iListboxContent):
    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, default_item_height=0): 
        _enigma.eListboxPythonStringContent_swiginit(self,_enigma.new_eListboxPythonStringContent(default_item_height))
    __swig_destroy__ = _enigma.delete_eListboxPythonStringContent
    setItemHeight = staticmethod(_enigma.eListboxPythonStringContent_setItemHeight)
    setFont = staticmethod(_enigma.eListboxPythonStringContent_setFont)
    setLeftOffset = staticmethod(_enigma.eListboxPythonStringContent_setLeftOffset)
    setRightOffset = staticmethod(_enigma.eListboxPythonStringContent_setRightOffset)
eListboxPythonStringContent.setList = new_instancemethod(_enigma.eListboxPythonStringContent_setList,None,eListboxPythonStringContent)
eListboxPythonStringContent.getCurrentSelection = new_instancemethod(_enigma.eListboxPythonStringContent_getCurrentSelection,None,eListboxPythonStringContent)
eListboxPythonStringContent.getCurrentSelectionIndex = new_instancemethod(_enigma.eListboxPythonStringContent_getCurrentSelectionIndex,None,eListboxPythonStringContent)
eListboxPythonStringContent.invalidateEntry = new_instancemethod(_enigma.eListboxPythonStringContent_invalidateEntry,None,eListboxPythonStringContent)
eListboxPythonStringContent.invalidate = new_instancemethod(_enigma.eListboxPythonStringContent_invalidate,None,eListboxPythonStringContent)
eListboxPythonStringContent.getItemSize = new_instancemethod(_enigma.eListboxPythonStringContent_getItemSize,None,eListboxPythonStringContent)
eListboxPythonStringContent_swigregister = _enigma.eListboxPythonStringContent_swigregister
eListboxPythonStringContent_swigregister(eListboxPythonStringContent)

def eListboxPythonStringContent_setItemHeight(*args):
  return _enigma.eListboxPythonStringContent_setItemHeight(*args)
eListboxPythonStringContent_setItemHeight = _enigma.eListboxPythonStringContent_setItemHeight

def eListboxPythonStringContent_setFont(*args):
  return _enigma.eListboxPythonStringContent_setFont(*args)
eListboxPythonStringContent_setFont = _enigma.eListboxPythonStringContent_setFont

def eListboxPythonStringContent_setLeftOffset(*args):
  return _enigma.eListboxPythonStringContent_setLeftOffset(*args)
eListboxPythonStringContent_setLeftOffset = _enigma.eListboxPythonStringContent_setLeftOffset

def eListboxPythonStringContent_setRightOffset(*args):
  return _enigma.eListboxPythonStringContent_setRightOffset(*args)
eListboxPythonStringContent_setRightOffset = _enigma.eListboxPythonStringContent_setRightOffset

class eListboxPythonConfigContent(eListboxPythonStringContent):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    setItemHeight = staticmethod(_enigma.eListboxPythonConfigContent_setItemHeight)
    setValueFont = staticmethod(_enigma.eListboxPythonConfigContent_setValueFont)
    setDescriptionFont = staticmethod(_enigma.eListboxPythonConfigContent_setDescriptionFont)
    def __init__(self): 
        _enigma.eListboxPythonConfigContent_swiginit(self,_enigma.new_eListboxPythonConfigContent())
    __swig_destroy__ = _enigma.delete_eListboxPythonConfigContent
eListboxPythonConfigContent.paint = new_instancemethod(_enigma.eListboxPythonConfigContent_paint,None,eListboxPythonConfigContent)
eListboxPythonConfigContent.setSeperation = new_instancemethod(_enigma.eListboxPythonConfigContent_setSeperation,None,eListboxPythonConfigContent)
eListboxPythonConfigContent.currentCursorSelectable = new_instancemethod(_enigma.eListboxPythonConfigContent_currentCursorSelectable,None,eListboxPythonConfigContent)
eListboxPythonConfigContent_swigregister = _enigma.eListboxPythonConfigContent_swigregister
eListboxPythonConfigContent_swigregister(eListboxPythonConfigContent)

def eListboxPythonConfigContent_setItemHeight(*args):
  return _enigma.eListboxPythonConfigContent_setItemHeight(*args)
eListboxPythonConfigContent_setItemHeight = _enigma.eListboxPythonConfigContent_setItemHeight

def eListboxPythonConfigContent_setValueFont(*args):
  return _enigma.eListboxPythonConfigContent_setValueFont(*args)
eListboxPythonConfigContent_setValueFont = _enigma.eListboxPythonConfigContent_setValueFont

def eListboxPythonConfigContent_setDescriptionFont(*args):
  return _enigma.eListboxPythonConfigContent_setDescriptionFont(*args)
eListboxPythonConfigContent_setDescriptionFont = _enigma.eListboxPythonConfigContent_setDescriptionFont

class eListboxPythonMultiContent(eListboxPythonStringContent):
    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): 
        _enigma.eListboxPythonMultiContent_swiginit(self,_enigma.new_eListboxPythonMultiContent())
    __swig_destroy__ = _enigma.delete_eListboxPythonMultiContent
    TYPE_TEXT = _enigma.eListboxPythonMultiContent_TYPE_TEXT
    TYPE_PROGRESS = _enigma.eListboxPythonMultiContent_TYPE_PROGRESS
    TYPE_PIXMAP = _enigma.eListboxPythonMultiContent_TYPE_PIXMAP
    TYPE_PIXMAP_ALPHATEST = _enigma.eListboxPythonMultiContent_TYPE_PIXMAP_ALPHATEST
    TYPE_PIXMAP_ALPHABLEND = _enigma.eListboxPythonMultiContent_TYPE_PIXMAP_ALPHABLEND
    TYPE_PROGRESS_PIXMAP = _enigma.eListboxPythonMultiContent_TYPE_PROGRESS_PIXMAP
eListboxPythonMultiContent.paint = new_instancemethod(_enigma.eListboxPythonMultiContent_paint,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.currentCursorSelectable = new_instancemethod(_enigma.eListboxPythonMultiContent_currentCursorSelectable,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.setList = new_instancemethod(_enigma.eListboxPythonMultiContent_setList,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.setFont = new_instancemethod(_enigma.eListboxPythonMultiContent_setFont,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.setBuildFunc = new_instancemethod(_enigma.eListboxPythonMultiContent_setBuildFunc,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.setSelectableFunc = new_instancemethod(_enigma.eListboxPythonMultiContent_setSelectableFunc,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.setItemHeight = new_instancemethod(_enigma.eListboxPythonMultiContent_setItemHeight,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.setSelectionEnable = new_instancemethod(_enigma.eListboxPythonMultiContent_setSelectionEnable,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.moveSelection = new_instancemethod(_enigma.eListboxPythonMultiContent_moveSelection,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.setSelectionClip = new_instancemethod(_enigma.eListboxPythonMultiContent_setSelectionClip,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.updateClip = new_instancemethod(_enigma.eListboxPythonMultiContent_updateClip,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.entryRemoved = new_instancemethod(_enigma.eListboxPythonMultiContent_entryRemoved,None,eListboxPythonMultiContent)
eListboxPythonMultiContent.setTemplate = new_instancemethod(_enigma.eListboxPythonMultiContent_setTemplate,None,eListboxPythonMultiContent)
eListboxPythonMultiContent_swigregister = _enigma.eListboxPythonMultiContent_swigregister
eListboxPythonMultiContent_swigregister(eListboxPythonMultiContent)

RT_HALIGN_LEFT = _enigma.RT_HALIGN_LEFT
RT_HALIGN_RIGHT = _enigma.RT_HALIGN_RIGHT
RT_HALIGN_CENTER = _enigma.RT_HALIGN_CENTER
RT_HALIGN_BLOCK = _enigma.RT_HALIGN_BLOCK
RT_VALIGN_TOP = _enigma.RT_VALIGN_TOP
RT_VALIGN_CENTER = _enigma.RT_VALIGN_CENTER
RT_VALIGN_BOTTOM = _enigma.RT_VALIGN_BOTTOM
RT_WRAP = _enigma.RT_WRAP
class eWindowStyle_ENUMS(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")
    __repr__ = _swig_repr
    styleLabel = _enigma.eWindowStyle_ENUMS_styleLabel
    styleListboxSelected = _enigma.eWindowStyle_ENUMS_styleListboxSelected
    styleListboxNormal = _enigma.eWindowStyle_ENUMS_styleListboxNormal
    styleListboxMarked = _enigma.eWindowStyle_ENUMS_styleListboxMarked
    styleListboxMarkedAndSelected = _enigma.eWindowStyle_ENUMS_styleListboxMarkedAndSelected
    frameButton = _enigma.eWindowStyle_ENUMS_frameButton
    frameListboxEntry = _enigma.eWindowStyle_ENUMS_frameListboxEntry
    fontStatic = _enigma.eWindowStyle_ENUMS_fontStatic
    fontButton = _enigma.eWindowStyle_ENUMS_fontButton
    fontTitlebar = _enigma.eWindowStyle_ENUMS_fontTitlebar
eWindowStyle_ENUMS_swigregister = _enigma.eWindowStyle_ENUMS_swigregister
eWindowStyle_ENUMS_swigregister(eWindowStyle_ENUMS)

eWindowStyle = eWindowStyle_ENUMS
class eWindowStylePtr(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): 
        _enigma.eWindowStylePtr_swiginit(self,_enigma.new_eWindowStylePtr(*args))
    __swig_destroy__ = _enigma.delete_eWindowStylePtr
eWindowStylePtr.__ref__ = new_instancemethod(_enigma.eWindowStylePtr___ref__,None,eWindowStylePtr)
eWindowStylePtr.getPtrString = new_instancemethod(_enigma.eWindowStylePtr_getPtrString,None,eWindowStylePtr)
eWindowStylePtr.__deref__ = new_instancemethod(_enigma.eWindowStylePtr___deref__,None,eWindowStylePtr)
eWindowStylePtr.getColor = new_instancemethod(_enigma.eWindowStylePtr_getColor,None,eWindowStylePtr)
eWindowStylePtr_swigregister = _enigma.eWindowStylePtr_swigregister
eWindowStylePtr_swigregister(eWindowStylePtr)

class eWindowStyleManager(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): 
        _enigma.eWindowStyleManager_swiginit(self,_enigma.new_eWindowStyleManager(*args))
    __swig_destroy__ = _enigma.delete_eWindowStyleManager
    getInstance = staticmethod(_enigma.eWindowStyleManager_getInstance)
eWindowStyleManager.__ref__ = new_instancemethod(_enigma.eWindowStyleManager___ref__,None,eWindowStyleManager)
eWindowStyleManager.getPtrString = new_instancemethod(_enigma.eWindowStyleManager_getPtrString,None,eWindowStyleManager)
eWindowStyleManager.__deref__ = new_instancemethod(_enigma.eWindowStyleManager___deref__,None,eWindowStyleManager)
eWindowStyleManager.getStyle = new_instancemethod(_enigma.eWindowStyleManager_getStyle,None,eWindowStyleManager)
eWindowStyleManager.setStyle = new_instancemethod(_enigma.eWindowStyleManager_setStyle,None,eWindowStyleManager)
eWindowStyleManager_swigregister = _enigma.eWindowStyleManager_swigregister
eWindowStyleManager_swigregister(eWindowStyleManager)

def eWindowStyleManager_getInstance():
  return _enigma.eWindowStyleManager_getInstance()
eWindowStyleManager_getInstance = _enigma.eWindowStyleManager_getInstance

class eWindowStyleSkinned(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): 
        _enigma.eWindowStyleSkinned_swiginit(self,_enigma.new_eWindowStyleSkinned())
    bsWindow = _enigma.eWindowStyleSkinned_bsWindow
    bsButton = _enigma.eWindowStyleSkinned_bsButton
    bsListboxEntry = _enigma.eWindowStyleSkinned_bsListboxEntry
    bpTopLeft = _enigma.eWindowStyleSkinned_bpTopLeft
    bpTop = _enigma.eWindowStyleSkinned_bpTop
    bpTopRight = _enigma.eWindowStyleSkinned_bpTopRight
    bpLeft = _enigma.eWindowStyleSkinned_bpLeft
    bpBackground = _enigma.eWindowStyleSkinned_bpBackground
    bpRight = _enigma.eWindowStyleSkinned_bpRight
    bpBottomLeft = _enigma.eWindowStyleSkinned_bpBottomLeft
    bpBottom = _enigma.eWindowStyleSkinned_bpBottom
    bpBottomRight = _enigma.eWindowStyleSkinned_bpBottomRight
    bpAll = _enigma.eWindowStyleSkinned_bpAll
    bpMax = _enigma.eWindowStyleSkinned_bpMax
    bpiTopLeft = _enigma.eWindowStyleSkinned_bpiTopLeft
    bpiTop = _enigma.eWindowStyleSkinned_bpiTop
    bpiTopRight = _enigma.eWindowStyleSkinned_bpiTopRight
    bpiLeft = _enigma.eWindowStyleSkinned_bpiLeft
    bpiBackground = _enigma.eWindowStyleSkinned_bpiBackground
    bpiRight = _enigma.eWindowStyleSkinned_bpiRight
    bpiBottomLeft = _enigma.eWindowStyleSkinned_bpiBottomLeft
    bpiBottom = _enigma.eWindowStyleSkinned_bpiBottom
    bpiBottomRight = _enigma.eWindowStyleSkinned_bpiBottomRight
    colBackground = _enigma.eWindowStyleSkinned_colBackground
    colLabelForeground = _enigma.eWindowStyleSkinned_colLabelForeground
    colListboxBackground = _enigma.eWindowStyleSkinned_colListboxBackground
    colListboxForeground = _enigma.eWindowStyleSkinned_colListboxForeground
    colListboxSelectedBackground = _enigma.eWindowStyleSkinned_colListboxSelectedBackground
    colListboxSelectedForeground = _enigma.eWindowStyleSkinned_colListboxSelectedForeground
    colListboxMarkedBackground = _enigma.eWindowStyleSkinned_colListboxMarkedBackground
    colListboxMarkedForeground = _enigma.eWindowStyleSkinned_colListboxMarkedForeground
    colListboxMarkedAndSelectedBackground = _enigma.eWindowStyleSkinned_colListboxMarkedAndSelectedBackground
    colListboxMarkedAndSelectedForeground = _enigma.eWindowStyleSkinned_colListboxMarkedAndSelectedForeground
    colWindowTitleForeground = _enigma.eWindowStyleSkinned_colWindowTitleForeground
    colWindowTitleBackground = _enigma.eWindowStyleSkinned_colWindowTitleBackground
    colWindowDimmer = _enigma.eWindowStyleSkinned_colWindowDimmer
    colMax = _enigma.eWindowStyleSkinned_colMax
    __swig_destroy__ = _enigma.delete_eWindowStyleSkinned
eWindowStyleSkinned.setStyle = new_instancemethod(_enigma.eWindowStyleSkinned_setStyle,None,eWindowStyleSkinned)
eWindowStyleSkinned.setPixmap = new_instancemethod(_enigma.eWindowStyleSkinned_setPixmap,None,eWindowStyleSkinned)
eWindowStyleSkinned.setColor = new_instancemethod(_enigma.eWindowStyleSkinned_setColor,None,eWindowStyleSkinned)
eWindowStyleSkinned.getColor = new_instancemethod(_enigma.eWindowStyleSkinned_getColor,None,eWindowStyleSkinned)
eWindowStyleSkinned.setTitleOffset = new_instancemethod(_enigma.eWindowStyleSkinned_setTitleOffset,None,eWindowStyleSkinned)
eWindowStyleSkinned.setTitleFont = new_instancemethod(_enigma.eWindowStyleSkinned_setTitleFont,None,eWindowStyleSkinned)
eWindowStyleSkinned_swigregister = _enigma.eWindowStyleSkinned_swigregister
eWindowStyleSkinned_swigregister(eWindowStyleSkinned)

class eWindowStyleScrollbar(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): 
        _enigma.eWindowStyleScrollbar_swiginit(self,_enigma.new_eWindowStyleScrollbar())
    __swig_destroy__ = _enigma.delete_eWindowStyleScrollbar
eWindowStyleScrollbar.getColor = new_instancemethod(_enigma.eWindowStyleScrollbar_getColor,None,eWindowStyleScrollbar)
eWindowStyleScrollbar.setBackgroundPixmap = new_instancemethod(_enigma.eWindowStyleScrollbar_setBackgroundPixmap,None,eWindowStyleScrollbar)
eWindowStyleScrollbar.setValuePixmap = new_instancemethod(_enigma.eWindowStyleScrollbar_setValuePixmap,None,eWindowStyleScrollbar)
eWindowStyleScrollbar.setBackgroundPixmapTopHeight = new_instancemethod(_enigma.eWindowStyleScrollbar_setBackgroundPixmapTopHeight,None,eWindowStyleScrollbar)
eWindowStyleScrollbar.setBackgroundPixmapBottomHeight = new_instancemethod(_enigma.eWindowStyleScrollbar_setBackgroundPixmapBottomHeight,None,eWindowStyleScrollbar)
eWindowStyleScrollbar.setValuePixmapTopHeight = new_instancemethod(_enigma.eWindowStyleScrollbar_setValuePixmapTopHeight,None,eWindowStyleScrollbar)
eWindowStyleScrollbar.setValuePixmapBottomHeight = new_instancemethod(_enigma.eWindowStyleScrollbar_setValuePixmapBottomHeight,None,eWindowStyleScrollbar)
eWindowStyleScrollbar.setScrollbarWidth = new_instancemethod(_enigma.eWindowStyleScrollbar_setScrollbarWidth,None,eWindowStyleScrollbar)
eWindowStyleScrollbar.setScrollbarBorderWidth = new_instancemethod(_enigma.eWindowStyleScrollbar_setScrollbarBorderWidth,None,eWindowStyleScrollbar)
eWindowStyleScrollbar_swigregister = _enigma.eWindowStyleScrollbar_swigregister
eWindowStyleScrollbar_swigregister(eWindowStyleScrollbar)

class eVideoWidget(eWidget):
    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): 
        _enigma.eVideoWidget_swiginit(self,_enigma.new_eVideoWidget(*args))
    __swig_destroy__ = _enigma.delete_eVideoWidget
eVideoWidget.setDecoder = new_instancemethod(_enigma.eVideoWidget_setDecoder,None,eVideoWidget)
eVideoWidget.setFBSize = new_instancemethod(_enigma.eVideoWidget_setFBSize,None,eVideoWidget)
eVideoWidget_swigregister = _enigma.eVideoWidget_swigregister
eVideoWidget_swigregister(eVideoWidget)

class ePangoSubtitlePageElement(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    m_color = _swig_property(_enigma.ePangoSubtitlePageElement_m_color_get, _enigma.ePangoSubtitlePageElement_m_color_set)
    m_have_color = _swig_property(_enigma.ePangoSubtitlePageElement_m_have_color_get, _enigma.ePangoSubtitlePageElement_m_have_color_set)
    m_pango_line = _swig_property(_enigma.ePangoSubtitlePageElement_m_pango_line_get, _enigma.ePangoSubtitlePageElement_m_pango_line_set)
    m_area = _swig_property(_enigma.ePangoSubtitlePageElement_m_area_get, _enigma.ePangoSubtitlePageElement_m_area_set)
    def __init__(self, *args): 
        _enigma.ePangoSubtitlePageElement_swiginit(self,_enigma.new_ePangoSubtitlePageElement(*args))
    __swig_destroy__ = _enigma.delete_ePangoSubtitlePageElement
ePangoSubtitlePageElement_swigregister = _enigma.ePangoSubtitlePageElement_swigregister
ePangoSubtitlePageElement_swigregister(ePangoSubtitlePageElement)

class ePangoSubtitlePage(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    m_show_pts = _swig_property(_enigma.ePangoSubtitlePage_m_show_pts_get, _enigma.ePangoSubtitlePage_m_show_pts_set)
    m_timeout = _swig_property(_enigma.ePangoSubtitlePage_m_timeout_get, _enigma.ePangoSubtitlePage_m_timeout_set)
    m_elements = _swig_property(_enigma.ePangoSubtitlePage_m_elements_get, _enigma.ePangoSubtitlePage_m_elements_set)
    def __init__(self): 
        _enigma.ePangoSubtitlePage_swiginit(self,_enigma.new_ePangoSubtitlePage())
    __swig_destroy__ = _enigma.delete_ePangoSubtitlePage
ePangoSubtitlePage.clear = new_instancemethod(_enigma.ePangoSubtitlePage_clear,None,ePangoSubtitlePage)
ePangoSubtitlePage_swigregister = _enigma.ePangoSubtitlePage_swigregister
ePangoSubtitlePage_swigregister(ePangoSubtitlePage)

class eVobSubtitlePage(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    m_show_pts = _swig_property(_enigma.eVobSubtitlePage_m_show_pts_get, _enigma.eVobSubtitlePage_m_show_pts_set)
    m_timeout = _swig_property(_enigma.eVobSubtitlePage_m_timeout_get, _enigma.eVobSubtitlePage_m_timeout_set)
    m_pixmap = _swig_property(_enigma.eVobSubtitlePage_m_pixmap_get, _enigma.eVobSubtitlePage_m_pixmap_set)
    def __init__(self): 
        _enigma.eVobSubtitlePage_swiginit(self,_enigma.new_eVobSubtitlePage())
    __swig_destroy__ = _enigma.delete_eVobSubtitlePage
eVobSubtitlePage_swigregister = _enigma.eVobSubtitlePage_swigregister
eVobSubtitlePage_swigregister(eVobSubtitlePage)

class eSubtitleWidget(eWidget):
    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): 
        _enigma.eSubtitleWidget_swiginit(self,_enigma.new_eSubtitleWidget(*args))
    Subtitle_TTX = _enigma.eSubtitleWidget_Subtitle_TTX
    Subtitle_Regular = _enigma.eSubtitleWidget_Subtitle_Regular
    Subtitle_Bold = _enigma.eSubtitleWidget_Subtitle_Bold
    Subtitle_Italic = _enigma.eSubtitleWidget_Subtitle_Italic
    Subtitle_MAX = _enigma.eSubtitleWidget_Subtitle_MAX
    setFontStyle = staticmethod(_enigma.eSubtitleWidget_setFontStyle)
    __swig_destroy__ = _enigma.delete_eSubtitleWidget
eSubtitleWidget.setPage = new_instancemethod(_enigma.eSubtitleWidget_setPage,None,eSubtitleWidget)
eSubtitleWidget.clearPage = new_instancemethod(_enigma.eSubtitleWidget_clearPage,None,eSubtitleWidget)
eSubtitleWidget.setPixmap = new_instancemethod(_enigma.eSubtitleWidget_setPixmap,None,eSubtitleWidget)
eSubtitleWidget_swigregister = _enigma.eSubtitleWidget_swigregister
eSubtitleWidget_swigregister(eSubtitleWidget)

def eSubtitleWidget_setFontStyle(*args):
  return _enigma.eSubtitleWidget_setFontStyle(*args)
eSubtitleWidget_setFontStyle = _enigma.eSubtitleWidget_setFontStyle

class Teletext(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    MODE_FULL = _enigma.Teletext_MODE_FULL
    MODE_UPPER_HALF = _enigma.Teletext_MODE_UPPER_HALF
    MODE_LOWER_HALF = _enigma.Teletext_MODE_LOWER_HALF
    def __init__(self): 
        _enigma.Teletext_swiginit(self,_enigma.new_Teletext())
    __swig_destroy__ = _enigma.delete_Teletext
Teletext.show = new_instancemethod(_enigma.Teletext_show,None,Teletext)
Teletext.hide = new_instancemethod(_enigma.Teletext_hide,None,Teletext)
Teletext.update = new_instancemethod(_enigma.Teletext_update,None,Teletext)
Teletext.getRenderBufferOffset = new_instancemethod(_enigma.Teletext_getRenderBufferOffset,None,Teletext)
Teletext.getRenderBufferStride = new_instancemethod(_enigma.Teletext_getRenderBufferStride,None,Teletext)
Teletext.getTextPidsAndName = new_instancemethod(_enigma.Teletext_getTextPidsAndName,None,Teletext)
Teletext_swigregister = _enigma.Teletext_swigregister
Teletext_swigregister(Teletext)

class eListboxServiceContent(eListboxPythonMultiContent):
    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): 
        _enigma.eListboxServiceContent_swiginit(self,_enigma.new_eListboxServiceContent())
    __swig_destroy__ = _enigma.delete_eListboxServiceContent
eListboxServiceContent.addService = new_instancemethod(_enigma.eListboxServiceContent_addService,None,eListboxServiceContent)
eListboxServiceContent.removeCurrent = new_instancemethod(_enigma.eListboxServiceContent_removeCurrent,None,eListboxServiceContent)
eListboxServiceContent.FillFinished = new_instancemethod(_enigma.eListboxServiceContent_FillFinished,None,eListboxServiceContent)
eListboxServiceContent.setRoot = new_instancemethod(_enigma.eListboxServiceContent_setRoot,None,eListboxServiceContent)
eListboxServiceContent.getCurrent = new_instancemethod(_enigma.eListboxServiceContent_getCurrent,None,eListboxServiceContent)
eListboxServiceContent.getNextBeginningWithChar = new_instancemethod(_enigma.eListboxServiceContent_getNextBeginningWithChar,None,eListboxServiceContent)
eListboxServiceContent.getPrevMarkerPos = new_instancemethod(_enigma.eListboxServiceContent_getPrevMarkerPos,None,eListboxServiceContent)
eListboxServiceContent.getNextMarkerPos = new_instancemethod(_enigma.eListboxServiceContent_getNextMarkerPos,None,eListboxServiceContent)
eListboxServiceContent.initMarked = new_instancemethod(_enigma.eListboxServiceContent_initMarked,None,eListboxServiceContent)
eListboxServiceContent.addMarked = new_instancemethod(_enigma.eListboxServiceContent_addMarked,None,eListboxServiceContent)
eListboxServiceContent.removeMarked = new_instancemethod(_enigma.eListboxServiceContent_removeMarked,None,eListboxServiceContent)
eListboxServiceContent.isMarked = new_instancemethod(_enigma.eListboxServiceContent_isMarked,None,eListboxServiceContent)
eListboxServiceContent.markedQueryStart = new_instancemethod(_enigma.eListboxServiceContent_markedQueryStart,None,eListboxServiceContent)
eListboxServiceContent.markedQueryNext = new_instancemethod(_enigma.eListboxServiceContent_markedQueryNext,None,eListboxServiceContent)
eListboxServiceContent.lookupService = new_instancemethod(_enigma.eListboxServiceContent_lookupService,None,eListboxServiceContent)
eListboxServiceContent.setCurrent = new_instancemethod(_enigma.eListboxServiceContent_setCurrent,None,eListboxServiceContent)
eListboxServiceContent.sort = new_instancemethod(_enigma.eListboxServiceContent_sort,None,eListboxServiceContent)
eListboxServiceContent.setCurrentMarked = new_instancemethod(_enigma.eListboxServiceContent_setCurrentMarked,None,eListboxServiceContent)
eListboxServiceContent.isCurrentMarked = new_instancemethod(_enigma.eListboxServiceContent_isCurrentMarked,None,eListboxServiceContent)
eListboxServiceContent.getNumMarkersBeforeCurrent = new_instancemethod(_enigma.eListboxServiceContent_getNumMarkersBeforeCurrent,None,eListboxServiceContent)
eListboxServiceContent_swigregister = _enigma.eListboxServiceContent_swigregister
eListboxServiceContent_swigregister(eListboxServiceContent)

class pNavigation(iObject):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    m_event = _swig_property(_enigma.pNavigation_m_event_get, _enigma.pNavigation_m_event_set)
    m_record_event = _swig_property(_enigma.pNavigation_m_record_event_get, _enigma.pNavigation_m_record_event_set)
    def __init__(self): 
        _enigma.pNavigation_swiginit(self,_enigma.new_pNavigation())
    __swig_destroy__ = _enigma.delete_pNavigation
pNavigation.playService = new_instancemethod(_enigma.pNavigation_playService,None,pNavigation)
pNavigation.stopService = new_instancemethod(_enigma.pNavigation_stopService,None,pNavigation)
pNavigation.pause = new_instancemethod(_enigma.pNavigation_pause,None,pNavigation)
pNavigation.getCurrentService = new_instancemethod(_enigma.pNavigation_getCurrentService,None,pNavigation)
pNavigation.recordService = new_instancemethod(_enigma.pNavigation_recordService,None,pNavigation)
pNavigation.stopRecordService = new_instancemethod(_enigma.pNavigation_stopRecordService,None,pNavigation)
pNavigation.getRecordings = new_instancemethod(_enigma.pNavigation_getRecordings,None,pNavigation)
pNavigation_swigregister = _enigma.pNavigation_swigregister
pNavigation_swigregister(pNavigation)

class eActionSlot(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): 
        if self.__class__ == eActionSlot:
            _self = None
        else:
            _self = self
        _enigma.eActionSlot_swiginit(self,_enigma.new_eActionSlot(_self, ))
    __swig_destroy__ = _enigma.delete_eActionSlot
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eActionSlot(self)
        return weakref_proxy(self)
eActionSlot.action_func1 = new_instancemethod(_enigma.eActionSlot_action_func1,None,eActionSlot)
eActionSlot.action_func2 = new_instancemethod(_enigma.eActionSlot_action_func2,None,eActionSlot)
eActionSlot_swigregister = _enigma.eActionSlot_swigregister
eActionSlot_swigregister(eActionSlot)

class eActionMap(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): 
        _enigma.eActionMap_swiginit(self,_enigma.new_eActionMap(*args))
    __swig_destroy__ = _enigma.delete_eActionMap
    getInstance = staticmethod(_enigma.eActionMap_getInstance)
    def bindAction(self, context, prio, func):
        class ePythonActionSlot(eActionSlot):
            def __init__(self, func1=None, func2=None):
                eActionSlot.__init__(self)
                if func1 is None:
                    self.action_func2=func2
                else:
                    self.action_func1=func1
        weak_ref = WeakMethodReference(func)
        slot = context and ePythonActionSlot(func2=weak_ref) \
               or ePythonActionSlot(func1=weak_ref)
        self.bindActionSlot(context, prio, slot)
        return slot
eActionMap.__ref__ = new_instancemethod(_enigma.eActionMap___ref__,None,eActionMap)
eActionMap.getPtrString = new_instancemethod(_enigma.eActionMap_getPtrString,None,eActionMap)
eActionMap.__deref__ = new_instancemethod(_enigma.eActionMap___deref__,None,eActionMap)
eActionMap.bindActionSlot = new_instancemethod(_enigma.eActionMap_bindActionSlot,None,eActionMap)
eActionMap.bindKey = new_instancemethod(_enigma.eActionMap_bindKey,None,eActionMap)
eActionMap.unbindKeyDomain = new_instancemethod(_enigma.eActionMap_unbindKeyDomain,None,eActionMap)
eActionMap.keyPressed = new_instancemethod(_enigma.eActionMap_keyPressed,None,eActionMap)
eActionMap_swigregister = _enigma.eActionMap_swigregister
eActionMap_swigregister(eActionMap)

def eActionMap_getInstance():
  return _enigma.eActionMap_getInstance()
eActionMap_getInstance = _enigma.eActionMap_getInstance

class gFont(iObject):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    family = _swig_property(_enigma.gFont_family_get, _enigma.gFont_family_set)
    pointSize = _swig_property(_enigma.gFont_pointSize_get, _enigma.gFont_pointSize_set)
    __swig_destroy__ = _enigma.delete_gFont
    def __init__(self, *args): 
        _enigma.gFont_swiginit(self,_enigma.new_gFont(*args))
gFont_swigregister = _enigma.gFont_swigregister
gFont_swigregister(gFont)


def loadImage(*args):
  return _enigma.loadImage(*args)
loadImage = _enigma.loadImage

def loadPNG(*args):
  return _enigma.loadPNG(*args)
loadPNG = _enigma.loadPNG

def loadJPG(*args):
  return _enigma.loadJPG(*args)
loadJPG = _enigma.loadJPG
class eDVBVolumecontrol(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.eDVBVolumecontrol_getInstance)
eDVBVolumecontrol.volumeUp = new_instancemethod(_enigma.eDVBVolumecontrol_volumeUp,None,eDVBVolumecontrol)
eDVBVolumecontrol.volumeDown = new_instancemethod(_enigma.eDVBVolumecontrol_volumeDown,None,eDVBVolumecontrol)
eDVBVolumecontrol.setVolume = new_instancemethod(_enigma.eDVBVolumecontrol_setVolume,None,eDVBVolumecontrol)
eDVBVolumecontrol.volumeMute = new_instancemethod(_enigma.eDVBVolumecontrol_volumeMute,None,eDVBVolumecontrol)
eDVBVolumecontrol.volumeUnMute = new_instancemethod(_enigma.eDVBVolumecontrol_volumeUnMute,None,eDVBVolumecontrol)
eDVBVolumecontrol.volumeToggleMute = new_instancemethod(_enigma.eDVBVolumecontrol_volumeToggleMute,None,eDVBVolumecontrol)
eDVBVolumecontrol.getVolume = new_instancemethod(_enigma.eDVBVolumecontrol_getVolume,None,eDVBVolumecontrol)
eDVBVolumecontrol.isMuted = new_instancemethod(_enigma.eDVBVolumecontrol_isMuted,None,eDVBVolumecontrol)
eDVBVolumecontrol_swigregister = _enigma.eDVBVolumecontrol_swigregister
eDVBVolumecontrol_swigregister(eDVBVolumecontrol)

def eDVBVolumecontrol_getInstance():
  return _enigma.eDVBVolumecontrol_getInstance()
eDVBVolumecontrol_getInstance = _enigma.eDVBVolumecontrol_getInstance

class eDVBSatelliteDiseqcParameters(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")
    __repr__ = _swig_repr
    AA = _enigma.eDVBSatelliteDiseqcParameters_AA
    AB = _enigma.eDVBSatelliteDiseqcParameters_AB
    BA = _enigma.eDVBSatelliteDiseqcParameters_BA
    BB = _enigma.eDVBSatelliteDiseqcParameters_BB
    SENDNO = _enigma.eDVBSatelliteDiseqcParameters_SENDNO
    NONE = _enigma.eDVBSatelliteDiseqcParameters_NONE
    V1_0 = _enigma.eDVBSatelliteDiseqcParameters_V1_0
    V1_1 = _enigma.eDVBSatelliteDiseqcParameters_V1_1
    V1_2 = _enigma.eDVBSatelliteDiseqcParameters_V1_2
    SMATV = _enigma.eDVBSatelliteDiseqcParameters_SMATV
    NO = _enigma.eDVBSatelliteDiseqcParameters_NO
    A = _enigma.eDVBSatelliteDiseqcParameters_A
    B = _enigma.eDVBSatelliteDiseqcParameters_B
eDVBSatelliteDiseqcParameters_swigregister = _enigma.eDVBSatelliteDiseqcParameters_swigregister
eDVBSatelliteDiseqcParameters_swigregister(eDVBSatelliteDiseqcParameters)

class eDVBSatelliteSwitchParameters(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")
    __repr__ = _swig_repr
    HILO = _enigma.eDVBSatelliteSwitchParameters_HILO
    ON = _enigma.eDVBSatelliteSwitchParameters_ON
    OFF = _enigma.eDVBSatelliteSwitchParameters_OFF
    HV = _enigma.eDVBSatelliteSwitchParameters_HV
    _14V = _enigma.eDVBSatelliteSwitchParameters__14V
    _18V = _enigma.eDVBSatelliteSwitchParameters__18V
    _0V = _enigma.eDVBSatelliteSwitchParameters__0V
    HV_13 = _enigma.eDVBSatelliteSwitchParameters_HV_13
eDVBSatelliteSwitchParameters_swigregister = _enigma.eDVBSatelliteSwitchParameters_swigregister
eDVBSatelliteSwitchParameters_swigregister(eDVBSatelliteSwitchParameters)

class eDVBSatelliteRotorParameters(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")
    __repr__ = _swig_repr
    NORTH = _enigma.eDVBSatelliteRotorParameters_NORTH
    SOUTH = _enigma.eDVBSatelliteRotorParameters_SOUTH
    EAST = _enigma.eDVBSatelliteRotorParameters_EAST
    WEST = _enigma.eDVBSatelliteRotorParameters_WEST
    FAST = _enigma.eDVBSatelliteRotorParameters_FAST
    SLOW = _enigma.eDVBSatelliteRotorParameters_SLOW
eDVBSatelliteRotorParameters_swigregister = _enigma.eDVBSatelliteRotorParameters_swigregister
eDVBSatelliteRotorParameters_swigregister(eDVBSatelliteRotorParameters)

class eDVBSatelliteLNBParameters(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")
    __repr__ = _swig_repr
    OFF = _enigma.eDVBSatelliteLNBParameters_OFF
    ON = _enigma.eDVBSatelliteLNBParameters_ON
    SatCR_positions = _swig_property(_enigma.eDVBSatelliteLNBParameters_SatCR_positions_get, _enigma.eDVBSatelliteLNBParameters_SatCR_positions_set)
    SatCR_idx = _swig_property(_enigma.eDVBSatelliteLNBParameters_SatCR_idx_get, _enigma.eDVBSatelliteLNBParameters_SatCR_idx_set)
    SatCRvco = _swig_property(_enigma.eDVBSatelliteLNBParameters_SatCRvco_get, _enigma.eDVBSatelliteLNBParameters_SatCRvco_set)
    UnicableTuningWord = _swig_property(_enigma.eDVBSatelliteLNBParameters_UnicableTuningWord_get, _enigma.eDVBSatelliteLNBParameters_UnicableTuningWord_set)
    UnicableConfigWord = _swig_property(_enigma.eDVBSatelliteLNBParameters_UnicableConfigWord_get, _enigma.eDVBSatelliteLNBParameters_UnicableConfigWord_set)
    guard_offset = _swig_property(_enigma.eDVBSatelliteLNBParameters_guard_offset_get, _enigma.eDVBSatelliteLNBParameters_guard_offset_set)
    LNBNum = _swig_property(_enigma.eDVBSatelliteLNBParameters_LNBNum_get, _enigma.eDVBSatelliteLNBParameters_LNBNum_set)
eDVBSatelliteLNBParameters_swigregister = _enigma.eDVBSatelliteLNBParameters_swigregister
eDVBSatelliteLNBParameters_swigregister(eDVBSatelliteLNBParameters)
guard_offset_min = _enigma.guard_offset_min
guard_offset_max = _enigma.guard_offset_max
guard_offset_step = _enigma.guard_offset_step
MAX_SATCR = _enigma.MAX_SATCR
MAX_LNBNUM = _enigma.MAX_LNBNUM

class eDVBSatelliteEquipmentControl(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")
    __repr__ = _swig_repr
    DELAY_AFTER_CONT_TONE_DISABLE_BEFORE_DISEQC = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_CONT_TONE_DISABLE_BEFORE_DISEQC
    DELAY_AFTER_FINAL_CONT_TONE_CHANGE = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_FINAL_CONT_TONE_CHANGE
    DELAY_AFTER_FINAL_VOLTAGE_CHANGE = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_FINAL_VOLTAGE_CHANGE
    DELAY_BETWEEN_DISEQC_REPEATS = _enigma.eDVBSatelliteEquipmentControl_DELAY_BETWEEN_DISEQC_REPEATS
    DELAY_AFTER_LAST_DISEQC_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_LAST_DISEQC_CMD
    DELAY_AFTER_TONEBURST = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_TONEBURST
    DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_SWITCH_CMDS = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_SWITCH_CMDS
    DELAY_BETWEEN_SWITCH_AND_MOTOR_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_BETWEEN_SWITCH_AND_MOTOR_CMD
    DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER
    DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_MOTOR_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_MOTOR_CMD
    DELAY_AFTER_MOTOR_STOP_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_MOTOR_STOP_CMD
    DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD
    DELAY_BEFORE_SEQUENCE_REPEAT = _enigma.eDVBSatelliteEquipmentControl_DELAY_BEFORE_SEQUENCE_REPEAT
    MOTOR_COMMAND_RETRIES = _enigma.eDVBSatelliteEquipmentControl_MOTOR_COMMAND_RETRIES
    MOTOR_RUNNING_TIMEOUT = _enigma.eDVBSatelliteEquipmentControl_MOTOR_RUNNING_TIMEOUT
    DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_SWITCH_CMDS = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_SWITCH_CMDS
    DELAY_AFTER_DISEQC_RESET_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_DISEQC_RESET_CMD
    DELAY_AFTER_DISEQC_PERIPHERIAL_POWERON_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_DISEQC_PERIPHERIAL_POWERON_CMD
    DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_UNICABLE_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_UNICABLE_CMD
    DELAY_AFTER_UNICABLE_CMD = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_UNICABLE_CMD
    DELAY_AFTER_UNICABLE_FINAL_VOLTAGE_CHANGE = _enigma.eDVBSatelliteEquipmentControl_DELAY_AFTER_UNICABLE_FINAL_VOLTAGE_CHANGE
    MAX_PARAMS = _enigma.eDVBSatelliteEquipmentControl_MAX_PARAMS
    getInstance = staticmethod(_enigma.eDVBSatelliteEquipmentControl_getInstance)
    setParam = staticmethod(_enigma.eDVBSatelliteEquipmentControl_setParam)
eDVBSatelliteEquipmentControl.clear = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_clear,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.addLNB = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_addLNB,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSlotMask = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSlotMask,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBLOFL = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBLOFL,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBLOFH = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBLOFH,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBThreshold = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBThreshold,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBIncreasedVoltage = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBIncreasedVoltage,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBPrio = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBPrio,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBNum = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBNum,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setDiSEqCMode = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setDiSEqCMode,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setToneburst = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setToneburst,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setRepeats = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setRepeats,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setCommittedCommand = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setCommittedCommand,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setUncommittedCommand = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setUncommittedCommand,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setCommandOrder = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setCommandOrder,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setFastDiSEqC = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setFastDiSEqC,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setSeqRepeat = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setSeqRepeat,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLongitude = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLongitude,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLatitude = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLatitude,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLoDirection = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLoDirection,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLaDirection = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLaDirection,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setUseInputpower = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setUseInputpower,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setInputpowerDelta = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setInputpowerDelta,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setRotorTurningSpeed = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setRotorTurningSpeed,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSatCR = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSatCR,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSatCRvco = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSatCRvco,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSatCRpositions = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSatCRpositions,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBSatCR = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBSatCR,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBSatCRvco = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBSatCRvco,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBSatCRpositions = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBSatCRpositions,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.addSatellite = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_addSatellite,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setVoltageMode = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setVoltageMode,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setToneMode = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setToneMode,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setRotorPosNum = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setRotorPosNum,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setTunerLinked = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setTunerLinked,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setTunerDepends = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setTunerDepends,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setSlotNotLinked = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setSlotNotLinked,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getFrequencyRangeList = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getFrequencyRangeList,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setRotorMoving = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setRotorMoving,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.isRotorMoving = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_isRotorMoving,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.canMeasureInputPower = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_canMeasureInputPower,None,eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl_swigregister = _enigma.eDVBSatelliteEquipmentControl_swigregister
eDVBSatelliteEquipmentControl_swigregister(eDVBSatelliteEquipmentControl)

def eDVBSatelliteEquipmentControl_getInstance():
  return _enigma.eDVBSatelliteEquipmentControl_getInstance()
eDVBSatelliteEquipmentControl_getInstance = _enigma.eDVBSatelliteEquipmentControl_getInstance

def eDVBSatelliteEquipmentControl_setParam(*args):
  return _enigma.eDVBSatelliteEquipmentControl_setParam(*args)
eDVBSatelliteEquipmentControl_setParam = _enigma.eDVBSatelliteEquipmentControl_setParam

class cachestate(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")
    __repr__ = _swig_repr
    state = _swig_property(_enigma.cachestate_state_get, _enigma.cachestate_state_set)
    tsid = _swig_property(_enigma.cachestate_tsid_get, _enigma.cachestate_tsid_set)
    onid = _swig_property(_enigma.cachestate_onid_get, _enigma.cachestate_onid_set)
    dvbnamespace = _swig_property(_enigma.cachestate_dvbnamespace_get, _enigma.cachestate_dvbnamespace_set)
    seconds = _swig_property(_enigma.cachestate_seconds_get, _enigma.cachestate_seconds_set)
    started = _enigma.cachestate_started
    stopped = _enigma.cachestate_stopped
    aborted = _enigma.cachestate_aborted
    deferred = _enigma.cachestate_deferred
    __swig_destroy__ = _enigma.delete_cachestate
cachestate.getTsid = new_instancemethod(_enigma.cachestate_getTsid,None,cachestate)
cachestate_swigregister = _enigma.cachestate_swigregister
cachestate_swigregister(cachestate)

class eEPGCache(iObject):
    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
    getInstance = staticmethod(_enigma.eEPGCache_getInstance)
    getStringHash = staticmethod(_enigma.eEPGCache_getStringHash)
    SIMILAR_BROADCASTINGS_SEARCH = _enigma.eEPGCache_SIMILAR_BROADCASTINGS_SEARCH
    EXAKT_TITLE_SEARCH = _enigma.eEPGCache_EXAKT_TITLE_SEARCH
    PARTIAL_TITLE_SEARCH = _enigma.eEPGCache_PARTIAL_TITLE_SEARCH
    PARTIAL_DESCRIPTION_SEARCH = _enigma.eEPGCache_PARTIAL_DESCRIPTION_SEARCH
    CASE_CHECK = _enigma.eEPGCache_CASE_CHECK
    NO_CASE_CHECK = _enigma.eEPGCache_NO_CASE_CHECK
    cacheState = _swig_property(_enigma.eEPGCache_cacheState_get, _enigma.eEPGCache_cacheState_set)
eEPGCache.load = new_instancemethod(_enigma.eEPGCache_load,None,eEPGCache)
eEPGCache.save = new_instancemethod(_enigma.eEPGCache_save,None,eEPGCache)
eEPGCache.setCacheFile = new_instancemethod(_enigma.eEPGCache_setCacheFile,None,eEPGCache)
eEPGCache.setCacheTimespan = new_instancemethod(_enigma.eEPGCache_setCacheTimespan,None,eEPGCache)
eEPGCache.setOutdatedEPGTimespan = new_instancemethod(_enigma.eEPGCache_setOutdatedEPGTimespan,None,eEPGCache)
eEPGCache.Lock = new_instancemethod(_enigma.eEPGCache_Lock,None,eEPGCache)
eEPGCache.Unlock = new_instancemethod(_enigma.eEPGCache_Unlock,None,eEPGCache)
eEPGCache.lookupEvent = new_instancemethod(_enigma.eEPGCache_lookupEvent,None,eEPGCache)
eEPGCache.search = new_instancemethod(_enigma.eEPGCache_search,None,eEPGCache)
eEPGCache.lookupEventId = new_instancemethod(_enigma.eEPGCache_lookupEventId,None,eEPGCache)
eEPGCache.lookupEventTime = new_instancemethod(_enigma.eEPGCache_lookupEventTime,None,eEPGCache)
eEPGCache_swigregister = _enigma.eEPGCache_swigregister
eEPGCache_swigregister(eEPGCache)

def eEPGCache_getInstance():
  return _enigma.eEPGCache_getInstance()
eEPGCache_getInstance = _enigma.eEPGCache_getInstance

def eEPGCache_getStringHash(*args):
  return _enigma.eEPGCache_getStringHash(*args)
eEPGCache_getStringHash = _enigma.eEPGCache_getStringHash

class eDVBFrontendParametersSatellite(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Polarisation_Horizontal = _enigma.eDVBFrontendParametersSatellite_Polarisation_Horizontal
    Polarisation_Vertical = _enigma.eDVBFrontendParametersSatellite_Polarisation_Vertical
    Polarisation_CircularLeft = _enigma.eDVBFrontendParametersSatellite_Polarisation_CircularLeft
    Polarisation_CircularRight = _enigma.eDVBFrontendParametersSatellite_Polarisation_CircularRight
    Inversion_Off = _enigma.eDVBFrontendParametersSatellite_Inversion_Off
    Inversion_On = _enigma.eDVBFrontendParametersSatellite_Inversion_On
    Inversion_Unknown = _enigma.eDVBFrontendParametersSatellite_Inversion_Unknown
    FEC_Auto = _enigma.eDVBFrontendParametersSatellite_FEC_Auto
    FEC_1_2 = _enigma.eDVBFrontendParametersSatellite_FEC_1_2
    FEC_2_3 = _enigma.eDVBFrontendParametersSatellite_FEC_2_3
    FEC_3_4 = _enigma.eDVBFrontendParametersSatellite_FEC_3_4
    FEC_5_6 = _enigma.eDVBFrontendParametersSatellite_FEC_5_6
    FEC_7_8 = _enigma.eDVBFrontendParametersSatellite_FEC_7_8
    FEC_8_9 = _enigma.eDVBFrontendParametersSatellite_FEC_8_9
    FEC_3_5 = _enigma.eDVBFrontendParametersSatellite_FEC_3_5
    FEC_4_5 = _enigma.eDVBFrontendParametersSatellite_FEC_4_5
    FEC_9_10 = _enigma.eDVBFrontendParametersSatellite_FEC_9_10
    FEC_None = _enigma.eDVBFrontendParametersSatellite_FEC_None
    System_DVB_S = _enigma.eDVBFrontendParametersSatellite_System_DVB_S
    System_DVB_S2 = _enigma.eDVBFrontendParametersSatellite_System_DVB_S2
    Modulation_Auto = _enigma.eDVBFrontendParametersSatellite_Modulation_Auto
    Modulation_QPSK = _enigma.eDVBFrontendParametersSatellite_Modulation_QPSK
    Modulation_8PSK = _enigma.eDVBFrontendParametersSatellite_Modulation_8PSK
    Modulation_QAM16 = _enigma.eDVBFrontendParametersSatellite_Modulation_QAM16
    RollOff_alpha_0_35 = _enigma.eDVBFrontendParametersSatellite_RollOff_alpha_0_35
    RollOff_alpha_0_25 = _enigma.eDVBFrontendParametersSatellite_RollOff_alpha_0_25
    RollOff_alpha_0_20 = _enigma.eDVBFrontendParametersSatellite_RollOff_alpha_0_20
    Pilot_Off = _enigma.eDVBFrontendParametersSatellite_Pilot_Off
    Pilot_On = _enigma.eDVBFrontendParametersSatellite_Pilot_On
    Pilot_Unknown = _enigma.eDVBFrontendParametersSatellite_Pilot_Unknown
    no_rotor_command_on_tune = _swig_property(_enigma.eDVBFrontendParametersSatellite_no_rotor_command_on_tune_get, _enigma.eDVBFrontendParametersSatellite_no_rotor_command_on_tune_set)
    frequency = _swig_property(_enigma.eDVBFrontendParametersSatellite_frequency_get, _enigma.eDVBFrontendParametersSatellite_frequency_set)
    symbol_rate = _swig_property(_enigma.eDVBFrontendParametersSatellite_symbol_rate_get, _enigma.eDVBFrontendParametersSatellite_symbol_rate_set)
    polarisation = _swig_property(_enigma.eDVBFrontendParametersSatellite_polarisation_get, _enigma.eDVBFrontendParametersSatellite_polarisation_set)
    fec = _swig_property(_enigma.eDVBFrontendParametersSatellite_fec_get, _enigma.eDVBFrontendParametersSatellite_fec_set)
    inversion = _swig_property(_enigma.eDVBFrontendParametersSatellite_inversion_get, _enigma.eDVBFrontendParametersSatellite_inversion_set)
    orbital_position = _swig_property(_enigma.eDVBFrontendParametersSatellite_orbital_position_get, _enigma.eDVBFrontendParametersSatellite_orbital_position_set)
    system = _swig_property(_enigma.eDVBFrontendParametersSatellite_system_get, _enigma.eDVBFrontendParametersSatellite_system_set)
    modulation = _swig_property(_enigma.eDVBFrontendParametersSatellite_modulation_get, _enigma.eDVBFrontendParametersSatellite_modulation_set)
    rolloff = _swig_property(_enigma.eDVBFrontendParametersSatellite_rolloff_get, _enigma.eDVBFrontendParametersSatellite_rolloff_set)
    pilot = _swig_property(_enigma.eDVBFrontendParametersSatellite_pilot_get, _enigma.eDVBFrontendParametersSatellite_pilot_set)
    def __init__(self): 
        _enigma.eDVBFrontendParametersSatellite_swiginit(self,_enigma.new_eDVBFrontendParametersSatellite())
    __swig_destroy__ = _enigma.delete_eDVBFrontendParametersSatellite
eDVBFrontendParametersSatellite_swigregister = _enigma.eDVBFrontendParametersSatellite_swigregister
eDVBFrontendParametersSatellite_swigregister(eDVBFrontendParametersSatellite)

class eDVBFrontendParametersCable(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Inversion_Off = _enigma.eDVBFrontendParametersCable_Inversion_Off
    Inversion_On = _enigma.eDVBFrontendParametersCable_Inversion_On
    Inversion_Unknown = _enigma.eDVBFrontendParametersCable_Inversion_Unknown
    FEC_Auto = _enigma.eDVBFrontendParametersCable_FEC_Auto
    FEC_1_2 = _enigma.eDVBFrontendParametersCable_FEC_1_2
    FEC_2_3 = _enigma.eDVBFrontendParametersCable_FEC_2_3
    FEC_3_4 = _enigma.eDVBFrontendParametersCable_FEC_3_4
    FEC_5_6 = _enigma.eDVBFrontendParametersCable_FEC_5_6
    FEC_7_8 = _enigma.eDVBFrontendParametersCable_FEC_7_8
    FEC_8_9 = _enigma.eDVBFrontendParametersCable_FEC_8_9
    FEC_None = _enigma.eDVBFrontendParametersCable_FEC_None
    Modulation_Auto = _enigma.eDVBFrontendParametersCable_Modulation_Auto
    Modulation_QAM16 = _enigma.eDVBFrontendParametersCable_Modulation_QAM16
    Modulation_QAM32 = _enigma.eDVBFrontendParametersCable_Modulation_QAM32
    Modulation_QAM64 = _enigma.eDVBFrontendParametersCable_Modulation_QAM64
    Modulation_QAM128 = _enigma.eDVBFrontendParametersCable_Modulation_QAM128
    Modulation_QAM256 = _enigma.eDVBFrontendParametersCable_Modulation_QAM256
    frequency = _swig_property(_enigma.eDVBFrontendParametersCable_frequency_get, _enigma.eDVBFrontendParametersCable_frequency_set)
    symbol_rate = _swig_property(_enigma.eDVBFrontendParametersCable_symbol_rate_get, _enigma.eDVBFrontendParametersCable_symbol_rate_set)
    modulation = _swig_property(_enigma.eDVBFrontendParametersCable_modulation_get, _enigma.eDVBFrontendParametersCable_modulation_set)
    inversion = _swig_property(_enigma.eDVBFrontendParametersCable_inversion_get, _enigma.eDVBFrontendParametersCable_inversion_set)
    fec_inner = _swig_property(_enigma.eDVBFrontendParametersCable_fec_inner_get, _enigma.eDVBFrontendParametersCable_fec_inner_set)
    def __init__(self): 
        _enigma.eDVBFrontendParametersCable_swiginit(self,_enigma.new_eDVBFrontendParametersCable())
    __swig_destroy__ = _enigma.delete_eDVBFrontendParametersCable
eDVBFrontendParametersCable_swigregister = _enigma.eDVBFrontendParametersCable_swigregister
eDVBFrontendParametersCable_swigregister(eDVBFrontendParametersCable)

class eDVBFrontendParametersTerrestrial(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    Bandwidth_8MHz = _enigma.eDVBFrontendParametersTerrestrial_Bandwidth_8MHz
    Bandwidth_7MHz = _enigma.eDVBFrontendParametersTerrestrial_Bandwidth_7MHz
    Bandwidth_6MHz = _enigma.eDVBFrontendParametersTerrestrial_Bandwidth_6MHz
    Bandwidth_Auto = _enigma.eDVBFrontendParametersTerrestrial_Bandwidth_Auto
    FEC_1_2 = _enigma.eDVBFrontendParametersTerrestrial_FEC_1_2
    FEC_2_3 = _enigma.eDVBFrontendParametersTerrestrial_FEC_2_3
    FEC_3_4 = _enigma.eDVBFrontendParametersTerrestrial_FEC_3_4
    FEC_5_6 = _enigma.eDVBFrontendParametersTerrestrial_FEC_5_6
    FEC_7_8 = _enigma.eDVBFrontendParametersTerrestrial_FEC_7_8
    FEC_Auto = _enigma.eDVBFrontendParametersTerrestrial_FEC_Auto
    TransmissionMode_2k = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_2k
    TransmissionMode_8k = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_8k
    TransmissionMode_Auto = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_Auto
    GuardInterval_1_32 = _enigma.eDVBFrontendParametersTerrestrial_GuardInterval_1_32
    GuardInterval_1_16 = _enigma.eDVBFrontendParametersTerrestrial_GuardInterval_1_16
    GuardInterval_1_8 = _enigma.eDVBFrontendParametersTerrestrial_GuardInterval_1_8
    GuardInterval_1_4 = _enigma.eDVBFrontendParametersTerrestrial_GuardInterval_1_4
    GuardInterval_Auto = _enigma.eDVBFrontendParametersTerrestrial_GuardInterval_Auto
    Hierarchy_None = _enigma.eDVBFrontendParametersTerrestrial_Hierarchy_None
    Hierarchy_1 = _enigma.eDVBFrontendParametersTerrestrial_Hierarchy_1
    Hierarchy_2 = _enigma.eDVBFrontendParametersTerrestrial_Hierarchy_2
    Hierarchy_4 = _enigma.eDVBFrontendParametersTerrestrial_Hierarchy_4
    Hierarchy_Auto = _enigma.eDVBFrontendParametersTerrestrial_Hierarchy_Auto
    Modulation_QPSK = _enigma.eDVBFrontendParametersTerrestrial_Modulation_QPSK
    Modulation_QAM16 = _enigma.eDVBFrontendParametersTerrestrial_Modulation_QAM16
    Modulation_QAM64 = _enigma.eDVBFrontendParametersTerrestrial_Modulation_QAM64
    Modulation_Auto = _enigma.eDVBFrontendParametersTerrestrial_Modulation_Auto
    Inversion_Off = _enigma.eDVBFrontendParametersTerrestrial_Inversion_Off
    Inversion_On = _enigma.eDVBFrontendParametersTerrestrial_Inversion_On
    Inversion_Unknown = _enigma.eDVBFrontendParametersTerrestrial_Inversion_Unknown
    frequency = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_frequency_get, _enigma.eDVBFrontendParametersTerrestrial_frequency_set)
    bandwidth = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_bandwidth_get, _enigma.eDVBFrontendParametersTerrestrial_bandwidth_set)
    code_rate_HP = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_code_rate_HP_get, _enigma.eDVBFrontendParametersTerrestrial_code_rate_HP_set)
    code_rate_LP = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_code_rate_LP_get, _enigma.eDVBFrontendParametersTerrestrial_code_rate_LP_set)
    modulation = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_modulation_get, _enigma.eDVBFrontendParametersTerrestrial_modulation_set)
    transmission_mode = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_transmission_mode_get, _enigma.eDVBFrontendParametersTerrestrial_transmission_mode_set)
    guard_interval = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_guard_interval_get, _enigma.eDVBFrontendParametersTerrestrial_guard_interval_set)
    hierarchy = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_hierarchy_get, _enigma.eDVBFrontendParametersTerrestrial_hierarchy_set)
    inversion = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_inversion_get, _enigma.eDVBFrontendParametersTerrestrial_inversion_set)
    def __init__(self): 
        _enigma.eDVBFrontendParametersTerrestrial_swiginit(self,_enigma.new_eDVBFrontendParametersTerrestrial())
    __swig_destroy__ = _enigma.delete_eDVBFrontendParametersTerrestrial
eDVBFrontendParametersTerrestrial_swigregister = _enigma.eDVBFrontendParametersTerrestrial_swigregister
eDVBFrontendParametersTerrestrial_swigregister(eDVBFrontendParametersTerrestrial)

class eDVBLocalTimeHandler(iObject):
    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
    m_timeUpdated = _swig_property(_enigma.eDVBLocalTimeHandler_m_timeUpdated_get, _enigma.eDVBLocalTimeHandler_m_timeUpdated_set)
    getInstance = staticmethod(_enigma.eDVBLocalTimeHandler_getInstance)
eDVBLocalTimeHandler.getUseDVBTime = new_instancemethod(_enigma.eDVBLocalTimeHandler_getUseDVBTime,None,eDVBLocalTimeHandler)
eDVBLocalTimeHandler.setUseDVBTime = new_instancemethod(_enigma.eDVBLocalTimeHandler_setUseDVBTime,None,eDVBLocalTimeHandler)
eDVBLocalTimeHandler.ready = new_instancemethod(_enigma.eDVBLocalTimeHandler_ready,None,eDVBLocalTimeHandler)
eDVBLocalTimeHandler_swigregister = _enigma.eDVBLocalTimeHandler_swigregister
eDVBLocalTimeHandler_swigregister(eDVBLocalTimeHandler)

def eDVBLocalTimeHandler_getInstance():
  return _enigma.eDVBLocalTimeHandler_getInstance()
eDVBLocalTimeHandler_getInstance = _enigma.eDVBLocalTimeHandler_getInstance

class iDVBFrontendParameters(iObject):
    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
    flagOnlyFree = _enigma.iDVBFrontendParameters_flagOnlyFree
iDVBFrontendParameters.getSystem = new_instancemethod(_enigma.iDVBFrontendParameters_getSystem,None,iDVBFrontendParameters)
iDVBFrontendParameters.getDVBS = new_instancemethod(_enigma.iDVBFrontendParameters_getDVBS,None,iDVBFrontendParameters)
iDVBFrontendParameters.getDVBC = new_instancemethod(_enigma.iDVBFrontendParameters_getDVBC,None,iDVBFrontendParameters)
iDVBFrontendParameters.getDVBT = new_instancemethod(_enigma.iDVBFrontendParameters_getDVBT,None,iDVBFrontendParameters)
iDVBFrontendParameters.getFlags = new_instancemethod(_enigma.iDVBFrontendParameters_getFlags,None,iDVBFrontendParameters)
iDVBFrontendParameters_swigregister = _enigma.iDVBFrontendParameters_swigregister
iDVBFrontendParameters_swigregister(iDVBFrontendParameters)

class iDVBFrontendParametersPtr(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): 
        _enigma.iDVBFrontendParametersPtr_swiginit(self,_enigma.new_iDVBFrontendParametersPtr(*args))
    __swig_destroy__ = _enigma.delete_iDVBFrontendParametersPtr
iDVBFrontendParametersPtr.__ref__ = new_instancemethod(_enigma.iDVBFrontendParametersPtr___ref__,None,iDVBFrontendParametersPtr)
iDVBFrontendParametersPtr.getPtrString = new_instancemethod(_enigma.iDVBFrontendParametersPtr_getPtrString,None,iDVBFrontendParametersPtr)
iDVBFrontendParametersPtr.__deref__ = new_instancemethod(_enigma.iDVBFrontendParametersPtr___deref__,None,iDVBFrontendParametersPtr)
iDVBFrontendParametersPtr.getSystem = new_instancemethod(_enigma.iDVBFrontendParametersPtr_getSystem,None,iDVBFrontendParametersPtr)
iDVBFrontendParametersPtr.getDVBS = new_instancemethod(_enigma.iDVBFrontendParametersPtr_getDVBS,None,iDVBFrontendParametersPtr)
iDVBFrontendParametersPtr.getDVBC = new_instancemethod(_enigma.iDVBFrontendParametersPtr_getDVBC,None,iDVBFrontendParametersPtr)
iDVBFrontendParametersPtr.getDVBT = new_instancemethod(_enigma.iDVBFrontendParametersPtr_getDVBT,None,iDVBFrontendParametersPtr)
iDVBFrontendParametersPtr.getFlags = new_instancemethod(_enigma.iDVBFrontendParametersPtr_getFlags,None,iDVBFrontendParametersPtr)
iDVBFrontendParametersPtr_swigregister = _enigma.iDVBFrontendParametersPtr_swigregister
iDVBFrontendParametersPtr_swigregister(iDVBFrontendParametersPtr)

MAX_DISEQC_LENGTH = _enigma.MAX_DISEQC_LENGTH
class eDVBDiseqcCommand(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): 
        _enigma.eDVBDiseqcCommand_swiginit(self,_enigma.new_eDVBDiseqcCommand())
    __swig_destroy__ = _enigma.delete_eDVBDiseqcCommand
eDVBDiseqcCommand.setCommandString = new_instancemethod(_enigma.eDVBDiseqcCommand_setCommandString,None,eDVBDiseqcCommand)
eDVBDiseqcCommand_swigregister = _enigma.eDVBDiseqcCommand_swigregister
eDVBDiseqcCommand_swigregister(eDVBDiseqcCommand)

class iDVBFrontend_ENUMS(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")
    __repr__ = _swig_repr
    feSatellite = _enigma.iDVBFrontend_ENUMS_feSatellite
    feCable = _enigma.iDVBFrontend_ENUMS_feCable
    feTerrestrial = _enigma.iDVBFrontend_ENUMS_feTerrestrial
    feSatellite2 = _enigma.iDVBFrontend_ENUMS_feSatellite2
    stateIdle = _enigma.iDVBFrontend_ENUMS_stateIdle
    stateTuning = _enigma.iDVBFrontend_ENUMS_stateTuning
    stateFailed = _enigma.iDVBFrontend_ENUMS_stateFailed
    stateLock = _enigma.iDVBFrontend_ENUMS_stateLock
    stateLostLock = _enigma.iDVBFrontend_ENUMS_stateLostLock
    statePreClose = _enigma.iDVBFrontend_ENUMS_statePreClose
    stateClosed = _enigma.iDVBFrontend_ENUMS_stateClosed
    toneOff = _enigma.iDVBFrontend_ENUMS_toneOff
    toneOn = _enigma.iDVBFrontend_ENUMS_toneOn
    voltageOff = _enigma.iDVBFrontend_ENUMS_voltageOff
    voltage13 = _enigma.iDVBFrontend_ENUMS_voltage13
    voltage18 = _enigma.iDVBFrontend_ENUMS_voltage18
    voltage13_5 = _enigma.iDVBFrontend_ENUMS_voltage13_5
    voltage18_5 = _enigma.iDVBFrontend_ENUMS_voltage18_5
    bitErrorRate = _enigma.iDVBFrontend_ENUMS_bitErrorRate
    signalPower = _enigma.iDVBFrontend_ENUMS_signalPower
    signalQuality = _enigma.iDVBFrontend_ENUMS_signalQuality
    locked = _enigma.iDVBFrontend_ENUMS_locked
    synced = _enigma.iDVBFrontend_ENUMS_synced
    frontendNumber = _enigma.iDVBFrontend_ENUMS_frontendNumber
    signalQualitydB = _enigma.iDVBFrontend_ENUMS_signalQualitydB
iDVBFrontend_ENUMS_swigregister = _enigma.iDVBFrontend_ENUMS_swigregister
iDVBFrontend_ENUMS_swigregister(iDVBFrontend_ENUMS)

iDVBFrontend = iDVBFrontend_ENUMS
class iDVBFrontendPtr(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): 
        _enigma.iDVBFrontendPtr_swiginit(self,_enigma.new_iDVBFrontendPtr(*args))
    __swig_destroy__ = _enigma.delete_iDVBFrontendPtr
iDVBFrontendPtr.__ref__ = new_instancemethod(_enigma.iDVBFrontendPtr___ref__,None,iDVBFrontendPtr)
iDVBFrontendPtr.getPtrString = new_instancemethod(_enigma.iDVBFrontendPtr_getPtrString,None,iDVBFrontendPtr)
iDVBFrontendPtr.__deref__ = new_instancemethod(_enigma.iDVBFrontendPtr___deref__,None,iDVBFrontendPtr)
iDVBFrontendPtr.getFrontendType = new_instancemethod(_enigma.iDVBFrontendPtr_getFrontendType,None,iDVBFrontendPtr)
iDVBFrontendPtr.tune = new_instancemethod(_enigma.iDVBFrontendPtr_tune,None,iDVBFrontendPtr)
iDVBFrontendPtr.closeFrontend = new_instancemethod(_enigma.iDVBFrontendPtr_closeFrontend,None,iDVBFrontendPtr)
iDVBFrontendPtr.reopenFrontend = new_instancemethod(_enigma.iDVBFrontendPtr_reopenFrontend,None,iDVBFrontendPtr)
iDVBFrontendPtr.getState = new_instancemethod(_enigma.iDVBFrontendPtr_getState,None,iDVBFrontendPtr)
iDVBFrontendPtr.setTone = new_instancemethod(_enigma.iDVBFrontendPtr_setTone,None,iDVBFrontendPtr)
iDVBFrontendPtr.setVoltage = new_instancemethod(_enigma.iDVBFrontendPtr_setVoltage,None,iDVBFrontendPtr)
iDVBFrontendPtr.sendDiseqc = new_instancemethod(_enigma.iDVBFrontendPtr_sendDiseqc,None,iDVBFrontendPtr)
iDVBFrontendPtr.sendToneburst = new_instancemethod(_enigma.iDVBFrontendPtr_sendToneburst,None,iDVBFrontendPtr)
iDVBFrontendPtr.readFrontendData = new_instancemethod(_enigma.iDVBFrontendPtr_readFrontendData,None,iDVBFrontendPtr)
iDVBFrontendPtr.getFrontendStatus = new_instancemethod(_enigma.iDVBFrontendPtr_getFrontendStatus,None,iDVBFrontendPtr)
iDVBFrontendPtr.getTransponderData = new_instancemethod(_enigma.iDVBFrontendPtr_getTransponderData,None,iDVBFrontendPtr)
iDVBFrontendPtr.getFrontendData = new_instancemethod(_enigma.iDVBFrontendPtr_getFrontendData,None,iDVBFrontendPtr)
iDVBFrontendPtr.getStateChangeSignal = new_instancemethod(_enigma.iDVBFrontendPtr_getStateChangeSignal,None,iDVBFrontendPtr)
iDVBFrontendPtr.changeType = new_instancemethod(_enigma.iDVBFrontendPtr_changeType,None,iDVBFrontendPtr)
iDVBFrontendPtr_swigregister = _enigma.iDVBFrontendPtr_swigregister
iDVBFrontendPtr_swigregister(iDVBFrontendPtr)

class iDVBChannelPtr(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): 
        _enigma.iDVBChannelPtr_swiginit(self,_enigma.new_iDVBChannelPtr(*args))
    __swig_destroy__ = _enigma.delete_iDVBChannelPtr
iDVBChannelPtr.__ref__ = new_instancemethod(_enigma.iDVBChannelPtr___ref__,None,iDVBChannelPtr)
iDVBChannelPtr.__deref__ = new_instancemethod(_enigma.iDVBChannelPtr___deref__,None,iDVBChannelPtr)
iDVBChannelPtr.getFrontend = new_instancemethod(_enigma.iDVBChannelPtr_getFrontend,None,iDVBChannelPtr)
iDVBChannelPtr.requestTsidOnid = new_instancemethod(_enigma.iDVBChannelPtr_requestTsidOnid,None,iDVBChannelPtr)
iDVBChannelPtr.reserveDemux = new_instancemethod(_enigma.iDVBChannelPtr_reserveDemux,None,iDVBChannelPtr)
iDVBChannelPtr_swigregister = _enigma.iDVBChannelPtr_swigregister
iDVBChannelPtr_swigregister(iDVBChannelPtr)

class eDVBResourceManager(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): 
        _enigma.eDVBResourceManager_swiginit(self,_enigma.new_eDVBResourceManager(*args))
    __swig_destroy__ = _enigma.delete_eDVBResourceManager
    getInstance = staticmethod(_enigma.eDVBResourceManager_getInstance)
    frontendUseMaskChanged = _swig_property(_enigma.eDVBResourceManager_frontendUseMaskChanged_get, _enigma.eDVBResourceManager_frontendUseMaskChanged_set)
eDVBResourceManager.__ref__ = new_instancemethod(_enigma.eDVBResourceManager___ref__,None,eDVBResourceManager)
eDVBResourceManager.getPtrString = new_instancemethod(_enigma.eDVBResourceManager_getPtrString,None,eDVBResourceManager)
eDVBResourceManager.__deref__ = new_instancemethod(_enigma.eDVBResourceManager___deref__,None,eDVBResourceManager)
eDVBResourceManager.canAllocateFrontend = new_instancemethod(_enigma.eDVBResourceManager_canAllocateFrontend,None,eDVBResourceManager)
eDVBResourceManager.canMeasureFrontendInputPower = new_instancemethod(_enigma.eDVBResourceManager_canMeasureFrontendInputPower,None,eDVBResourceManager)
eDVBResourceManager.allocateRawChannel = new_instancemethod(_enigma.eDVBResourceManager_allocateRawChannel,None,eDVBResourceManager)
eDVBResourceManager.setFrontendSlotInformations = new_instancemethod(_enigma.eDVBResourceManager_setFrontendSlotInformations,None,eDVBResourceManager)
eDVBResourceManager_swigregister = _enigma.eDVBResourceManager_swigregister
eDVBResourceManager_swigregister(eDVBResourceManager)

def eDVBResourceManager_getInstance():
  return _enigma.eDVBResourceManager_getInstance()
eDVBResourceManager_getInstance = _enigma.eDVBResourceManager_getInstance

class eDVBFrontendParameters(iDVBFrontendParameters):
    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): 
        _enigma.eDVBFrontendParameters_swiginit(self,_enigma.new_eDVBFrontendParameters())
    __swig_destroy__ = _enigma.delete_eDVBFrontendParameters
eDVBFrontendParameters.setDVBS = new_instancemethod(_enigma.eDVBFrontendParameters_setDVBS,None,eDVBFrontendParameters)
eDVBFrontendParameters.setDVBC = new_instancemethod(_enigma.eDVBFrontendParameters_setDVBC,None,eDVBFrontendParameters)
eDVBFrontendParameters.setDVBT = new_instancemethod(_enigma.eDVBFrontendParameters_setDVBT,None,eDVBFrontendParameters)
eDVBFrontendParameters.setFlags = new_instancemethod(_enigma.eDVBFrontendParameters_setFlags,None,eDVBFrontendParameters)
eDVBFrontendParameters_swigregister = _enigma.eDVBFrontendParameters_swigregister
eDVBFrontendParameters_swigregister(eDVBFrontendParameters)

class eDVBServicePMTHandler(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")
    __repr__ = _swig_repr
    setDDPSupport = staticmethod(_enigma.eDVBServicePMTHandler_setDDPSupport)
    eventNoResources = _enigma.eDVBServicePMTHandler_eventNoResources
    eventTuneFailed = _enigma.eDVBServicePMTHandler_eventTuneFailed
    eventNoPAT = _enigma.eDVBServicePMTHandler_eventNoPAT
    eventNoPATEntry = _enigma.eDVBServicePMTHandler_eventNoPATEntry
    eventNoPMT = _enigma.eDVBServicePMTHandler_eventNoPMT
    eventNewProgramInfo = _enigma.eDVBServicePMTHandler_eventNewProgramInfo
    eventUpdateDecoder = _enigma.eDVBServicePMTHandler_eventUpdateDecoder
    eventTuned = _enigma.eDVBServicePMTHandler_eventTuned
    eventNewSDT = _enigma.eDVBServicePMTHandler_eventNewSDT
    eventPreStart = _enigma.eDVBServicePMTHandler_eventPreStart
    eventSOF = _enigma.eDVBServicePMTHandler_eventSOF
    eventEOF = _enigma.eDVBServicePMTHandler_eventEOF
    eventMisconfiguration = _enigma.eDVBServicePMTHandler_eventMisconfiguration
    __swig_destroy__ = _enigma.delete_eDVBServicePMTHandler
eDVBServicePMTHandler_swigregister = _enigma.eDVBServicePMTHandler_swigregister
eDVBServicePMTHandler_swigregister(eDVBServicePMTHandler)

def eDVBServicePMTHandler_setDDPSupport(*args):
  return _enigma.eDVBServicePMTHandler_setDDPSupport(*args)
eDVBServicePMTHandler_setDDPSupport = _enigma.eDVBServicePMTHandler_setDDPSupport

class eDeviceEventManager(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): 
        _enigma.eDeviceEventManager_swiginit(self,_enigma.new_eDeviceEventManager())
    __swig_destroy__ = _enigma.delete_eDeviceEventManager
    event = _swig_property(_enigma.eDeviceEventManager_event_get, _enigma.eDeviceEventManager_event_set)
eDeviceEventManager.addSubsystemFilter = new_instancemethod(_enigma.eDeviceEventManager_addSubsystemFilter,None,eDeviceEventManager)
eDeviceEventManager.monitor = new_instancemethod(_enigma.eDeviceEventManager_monitor,None,eDeviceEventManager)
eDeviceEventManager.trigger = new_instancemethod(_enigma.eDeviceEventManager_trigger,None,eDeviceEventManager)
eDeviceEventManager_swigregister = _enigma.eDeviceEventManager_swigregister
eDeviceEventManager_swigregister(eDeviceEventManager)

class eComponentScan(iObject):
    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): 
        _enigma.eComponentScan_swiginit(self,_enigma.new_eComponentScan())
    __swig_destroy__ = _enigma.delete_eComponentScan
    statusChanged = _swig_property(_enigma.eComponentScan_statusChanged_get, _enigma.eComponentScan_statusChanged_set)
    newService = _swig_property(_enigma.eComponentScan_newService_get, _enigma.eComponentScan_newService_set)
    scanNetworkSearch = _enigma.eComponentScan_scanNetworkSearch
    scanRemoveServices = _enigma.eComponentScan_scanRemoveServices
    scanDontRemoveFeeds = _enigma.eComponentScan_scanDontRemoveFeeds
    scanDontRemoveUnscanned = _enigma.eComponentScan_scanDontRemoveUnscanned
    clearToScanOnFirstNIT = _enigma.eComponentScan_clearToScanOnFirstNIT
    scanOnlyFree = _enigma.eComponentScan_scanOnlyFree
    scanDontSkipEmptyTransponders = _enigma.eComponentScan_scanDontSkipEmptyTransponders
    scanOtherSDT = _enigma.eComponentScan_scanOtherSDT
eComponentScan.getProgress = new_instancemethod(_enigma.eComponentScan_getProgress,None,eComponentScan)
eComponentScan.getNumServices = new_instancemethod(_enigma.eComponentScan_getNumServices,None,eComponentScan)
eComponentScan.isDone = new_instancemethod(_enigma.eComponentScan_isDone,None,eComponentScan)
eComponentScan.getLastServiceName = new_instancemethod(_enigma.eComponentScan_getLastServiceName,None,eComponentScan)
eComponentScan.getError = new_instancemethod(_enigma.eComponentScan_getError,None,eComponentScan)
eComponentScan.clear = new_instancemethod(_enigma.eComponentScan_clear,None,eComponentScan)
eComponentScan.addInitial = new_instancemethod(_enigma.eComponentScan_addInitial,None,eComponentScan)
eComponentScan.start = new_instancemethod(_enigma.eComponentScan_start,None,eComponentScan)
eComponentScan.setAdditionalTsidOnidCheckFunc = new_instancemethod(_enigma.eComponentScan_setAdditionalTsidOnidCheckFunc,None,eComponentScan)
eComponentScan.getFrontend = new_instancemethod(_enigma.eComponentScan_getFrontend,None,eComponentScan)
eComponentScan.getCurrentTransponder = new_instancemethod(_enigma.eComponentScan_getCurrentTransponder,None,eComponentScan)
eComponentScan_swigregister = _enigma.eComponentScan_swigregister
eComponentScan_swigregister(eComponentScan)

class eBackgroundFileEraser(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.eBackgroundFileEraser_getInstance)
    fileErased = _swig_property(_enigma.eBackgroundFileEraser_fileErased_get, _enigma.eBackgroundFileEraser_fileErased_set)
eBackgroundFileEraser.erase = new_instancemethod(_enigma.eBackgroundFileEraser_erase,None,eBackgroundFileEraser)
eBackgroundFileEraser_swigregister = _enigma.eBackgroundFileEraser_swigregister
eBackgroundFileEraser_swigregister(eBackgroundFileEraser)

def eBackgroundFileEraser_getInstance():
  return _enigma.eBackgroundFileEraser_getInstance()
eBackgroundFileEraser_getInstance = _enigma.eBackgroundFileEraser_getInstance

class eMusicPlayer(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    callback = _swig_property(_enigma.eMusicPlayer_callback_get, _enigma.eMusicPlayer_callback_set)
    def __init__(self, *args): 
        _enigma.eMusicPlayer_swiginit(self,_enigma.new_eMusicPlayer(*args))
    __swig_destroy__ = _enigma.delete_eMusicPlayer
eMusicPlayer.getMetaInfos = new_instancemethod(_enigma.eMusicPlayer_getMetaInfos,None,eMusicPlayer)
eMusicPlayer.getStreamingURL = new_instancemethod(_enigma.eMusicPlayer_getStreamingURL,None,eMusicPlayer)
eMusicPlayer.play = new_instancemethod(_enigma.eMusicPlayer_play,None,eMusicPlayer)
eMusicPlayer.Stop = new_instancemethod(_enigma.eMusicPlayer_Stop,None,eMusicPlayer)
eMusicPlayer.setBands = new_instancemethod(_enigma.eMusicPlayer_setBands,None,eMusicPlayer)
eMusicPlayer_swigregister = _enigma.eMusicPlayer_swigregister
eMusicPlayer_swigregister(eMusicPlayer)

class eMediaDatabaseResult(iObject):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(eMediaDatabaseResult self) -> eMediaDatabaseResult"""
        _enigma.eMediaDatabaseResult_swiginit(self,_enigma.new_eMediaDatabaseResult())
    __swig_destroy__ = _enigma.delete_eMediaDatabaseResult
    def error(self):
        """error(eMediaDatabaseResult self) -> bool"""
        return _enigma.eMediaDatabaseResult_error(self)

    def rowsAffected(self):
        """rowsAffected(eMediaDatabaseResult self) -> int"""
        return _enigma.eMediaDatabaseResult_rowsAffected(self)

    def lastInsertId(self):
        """lastInsertId(eMediaDatabaseResult self) -> int"""
        return _enigma.eMediaDatabaseResult_lastInsertId(self)

    def errorDriverText(self):
        """errorDriverText(eMediaDatabaseResult self) -> std::string"""
        return _enigma.eMediaDatabaseResult_errorDriverText(self)

    def errorDatabaseText(self):
        """errorDatabaseText(eMediaDatabaseResult self) -> std::string"""
        return _enigma.eMediaDatabaseResult_errorDatabaseText(self)

    def data(self):
        """data(eMediaDatabaseResult self) -> StringMapVector"""
        return _enigma.eMediaDatabaseResult_data(self)

eMediaDatabaseResult.error = new_instancemethod(_enigma.eMediaDatabaseResult_error,None,eMediaDatabaseResult)
eMediaDatabaseResult.rowsAffected = new_instancemethod(_enigma.eMediaDatabaseResult_rowsAffected,None,eMediaDatabaseResult)
eMediaDatabaseResult.lastInsertId = new_instancemethod(_enigma.eMediaDatabaseResult_lastInsertId,None,eMediaDatabaseResult)
eMediaDatabaseResult.errorDriverText = new_instancemethod(_enigma.eMediaDatabaseResult_errorDriverText,None,eMediaDatabaseResult)
eMediaDatabaseResult.errorDatabaseText = new_instancemethod(_enigma.eMediaDatabaseResult_errorDatabaseText,None,eMediaDatabaseResult)
eMediaDatabaseResult.data = new_instancemethod(_enigma.eMediaDatabaseResult_data,None,eMediaDatabaseResult)
eMediaDatabaseResult_swigregister = _enigma.eMediaDatabaseResult_swigregister
eMediaDatabaseResult_swigregister(eMediaDatabaseResult)

class eMediaDatabase(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")
    __repr__ = _swig_repr
    def getInstance():
        """getInstance() -> eMediaDatabase"""
        return _enigma.eMediaDatabase_getInstance()

    getInstance = staticmethod(getInstance)
    def getCurrentScanPath(self):
        """getCurrentScanPath(eMediaDatabase self) -> std::string"""
        return _enigma.eMediaDatabase_getCurrentScanPath(self)

    def getEnqueuedPaths(self):
        """getEnqueuedPaths(eMediaDatabase self) -> StringVector"""
        return _enigma.eMediaDatabase_getEnqueuedPaths(self)

    def addPath(self, *args):
        """
        addPath(eMediaDatabase self, std::string const & path, bool watch=False)
        addPath(eMediaDatabase self, std::string const & path)
        """
        return _enigma.eMediaDatabase_addPath(self, *args)

    def rescanPath(self, *args):
        """
        rescanPath(eMediaDatabase self, std::string const & path, bool isRecording=False)
        rescanPath(eMediaDatabase self, std::string const & path)
        """
        return _enigma.eMediaDatabase_rescanPath(self, *args)

    def requestScanStatistics(self):
        """requestScanStatistics(eMediaDatabase self) -> bool"""
        return _enigma.eMediaDatabase_requestScanStatistics(self)

    def setParentDirectoryWatched(self, *args):
        """setParentDirectoryWatched(eMediaDatabase self, int dir_id, bool watched) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_setParentDirectoryWatched(self, *args)

    def deleteParentDirectory(self, *args):
        """deleteParentDirectory(eMediaDatabase self, int dir_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_deleteParentDirectory(self, *args)

    def getParentDirectories(self):
        """getParentDirectories(eMediaDatabase self) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getParentDirectories(self)

    def filterAudio(self, *args):
        """
        filterAudio(eMediaDatabase self, std::string const & needle, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        filterAudio(eMediaDatabase self, std::string const & needle, int limit=-1) -> eMediaDatabaseResultPtr
        filterAudio(eMediaDatabase self, std::string const & needle) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_filterAudio(self, *args)

    def filterByAlbum(self, *args):
        """
        filterByAlbum(eMediaDatabase self, std::string const & album, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        filterByAlbum(eMediaDatabase self, std::string const & album, int limit=-1) -> eMediaDatabaseResultPtr
        filterByAlbum(eMediaDatabase self, std::string const & album) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_filterByAlbum(self, *args)

    def filterByArtistAlbum(self, *args):
        """
        filterByArtistAlbum(eMediaDatabase self, std::string const & artist, std::string const & album, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        filterByArtistAlbum(eMediaDatabase self, std::string const & artist, std::string const & album, int limit=-1) -> eMediaDatabaseResultPtr
        filterByArtistAlbum(eMediaDatabase self, std::string const & artist, std::string const & album) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_filterByArtistAlbum(self, *args)

    def filterByArtist(self, *args):
        """
        filterByArtist(eMediaDatabase self, std::string const & artist, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        filterByArtist(eMediaDatabase self, std::string const & artist, int limit=-1) -> eMediaDatabaseResultPtr
        filterByArtist(eMediaDatabase self, std::string const & artist) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_filterByArtist(self, *args)

    def filterByGenre(self, *args):
        """
        filterByGenre(eMediaDatabase self, std::string const & genre, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        filterByGenre(eMediaDatabase self, std::string const & genre, int limit=-1) -> eMediaDatabaseResultPtr
        filterByGenre(eMediaDatabase self, std::string const & genre) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_filterByGenre(self, *args)

    def filterByTitle(self, *args):
        """
        filterByTitle(eMediaDatabase self, std::string const & title, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        filterByTitle(eMediaDatabase self, std::string const & title, int limit=-1) -> eMediaDatabaseResultPtr
        filterByTitle(eMediaDatabase self, std::string const & title) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_filterByTitle(self, *args)

    def getAllArtists(self, *args):
        """
        getAllArtists(eMediaDatabase self, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAllArtists(eMediaDatabase self, int limit=-1) -> eMediaDatabaseResultPtr
        getAllArtists(eMediaDatabase self) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAllArtists(self, *args)

    def getAllAlbumArtists(self, *args):
        """
        getAllAlbumArtists(eMediaDatabase self, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAllAlbumArtists(eMediaDatabase self, int limit=-1) -> eMediaDatabaseResultPtr
        getAllAlbumArtists(eMediaDatabase self) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAllAlbumArtists(self, *args)

    def getArtists(self, *args):
        """
        getArtists(eMediaDatabase self, std::string const & artist, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getArtists(eMediaDatabase self, std::string const & artist, int limit=-1) -> eMediaDatabaseResultPtr
        getArtists(eMediaDatabase self, std::string const & artist) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getArtists(self, *args)

    def getAllAlbums(self, *args):
        """
        getAllAlbums(eMediaDatabase self, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAllAlbums(eMediaDatabase self, int limit=-1) -> eMediaDatabaseResultPtr
        getAllAlbums(eMediaDatabase self) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAllAlbums(self, *args)

    def getAlbums(self, *args):
        """
        getAlbums(eMediaDatabase self, std::string const & album, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAlbums(eMediaDatabase self, std::string const & album, int limit=-1) -> eMediaDatabaseResultPtr
        getAlbums(eMediaDatabase self, std::string const & album) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAlbums(self, *args)

    def getAlbumsByArtist(self, *args):
        """
        getAlbumsByArtist(eMediaDatabase self, std::string const & artist, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAlbumsByArtist(eMediaDatabase self, std::string const & artist, int limit=-1) -> eMediaDatabaseResultPtr
        getAlbumsByArtist(eMediaDatabase self, std::string const & artist) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAlbumsByArtist(self, *args)

    def getAlbumsByAlbumArtist(self, *args):
        """
        getAlbumsByAlbumArtist(eMediaDatabase self, std::string const & album_artist, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAlbumsByAlbumArtist(eMediaDatabase self, std::string const & album_artist, int limit=-1) -> eMediaDatabaseResultPtr
        getAlbumsByAlbumArtist(eMediaDatabase self, std::string const & album_artist) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAlbumsByAlbumArtist(self, *args)

    def getAllAudio(self, *args):
        """
        getAllAudio(eMediaDatabase self, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAllAudio(eMediaDatabase self, int limit=-1) -> eMediaDatabaseResultPtr
        getAllAudio(eMediaDatabase self) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAllAudio(self, *args)

    def getAllVideos(self, *args):
        """
        getAllVideos(eMediaDatabase self, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAllVideos(eMediaDatabase self, int limit=-1) -> eMediaDatabaseResultPtr
        getAllVideos(eMediaDatabase self) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAllVideos(self, *args)

    def addRecording(self, *args):
        """addRecording(eMediaDatabase self, std::string const & filepath, std::string const & title, int created) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_addRecording(self, *args)

    def getAllRecordings(self, *args):
        """
        getAllRecordings(eMediaDatabase self, int limit=-1, int offset=0) -> eMediaDatabaseResultPtr
        getAllRecordings(eMediaDatabase self, int limit=-1) -> eMediaDatabaseResultPtr
        getAllRecordings(eMediaDatabase self) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getAllRecordings(self, *args)

    def getRecordings(self, *args):
        """
        getRecordings(eMediaDatabase self, std::string const & dir, StringList tags=std::list< std::string >(), int limit=-1, 
            int offset=0) -> eMediaDatabaseResultPtr
        getRecordings(eMediaDatabase self, std::string const & dir, StringList tags=std::list< std::string >(), int limit=-1) -> eMediaDatabaseResultPtr
        getRecordings(eMediaDatabase self, std::string const & dir, StringList tags=std::list< std::string >()) -> eMediaDatabaseResultPtr
        getRecordings(eMediaDatabase self, std::string const & dir) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getRecordings(self, *args)

    def getRecordMeta(self, *args):
        """getRecordMeta(eMediaDatabase self, int file_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getRecordMeta(self, *args)

    def setRecordMeta(self, *args):
        """
        setRecordMeta(eMediaDatabase self, int file_id, std::string const & ref, std::string const & name, std::string const & description, 
            std::string const & service_data, int64_t duration, int64_t filesize) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_setRecordMeta(self, *args)

    def getRecordEit(self, *args):
        """getRecordEit(eMediaDatabase self, int file_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getRecordEit(self, *args)

    def setRecordEit(self, *args):
        """setRecordEit(eMediaDatabase self, int file_id, uint8_t [] eit_raw) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_setRecordEit(self, *args)

    def getFileByPath(self, *args):
        """getFileByPath(eMediaDatabase self, std::string const & filepath) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getFileByPath(self, *args)

    def setFileAttribute(self, *args):
        """setFileAttribute(eMediaDatabase self, int file_id, std::string const & key, std::string const & value) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_setFileAttribute(self, *args)

    def deleteFileAttribute(self, *args):
        """deleteFileAttribute(eMediaDatabase self, int file_id, std::string const & key) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_deleteFileAttribute(self, *args)

    def getFileAttributes(self, *args):
        """getFileAttributes(eMediaDatabase self, int file_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getFileAttributes(self, *args)

    def getFileAttribute(self, *args):
        """getFileAttribute(eMediaDatabase self, int file_id, std::string const & key) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getFileAttribute(self, *args)

    def addPlaylist(self, *args):
        """addPlaylist(eMediaDatabase self, std::string const & name, int type) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_addPlaylist(self, *args)

    def getPlaylist(self, *args):
        """getPlaylist(eMediaDatabase self, int id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getPlaylist(self, *args)

    def getPlaylistByName(self, *args):
        """getPlaylistByName(eMediaDatabase self, std::string const & name, int type) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getPlaylistByName(self, *args)

    def getPlaylistItemsById(self, *args):
        """getPlaylistItemsById(eMediaDatabase self, int id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getPlaylistItemsById(self, *args)

    def getPlaylistItemsByName(self, *args):
        """
        getPlaylistItemsByName(eMediaDatabase self, std::string const & name, int type=-1) -> eMediaDatabaseResultPtr
        getPlaylistItemsByName(eMediaDatabase self, std::string const & name) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getPlaylistItemsByName(self, *args)

    def getPlaylists(self, *args):
        """
        getPlaylists(eMediaDatabase self, int type=-1) -> eMediaDatabaseResultPtr
        getPlaylists(eMediaDatabase self) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getPlaylists(self, *args)

    def addToPlaylistById(self, *args):
        """addToPlaylistById(eMediaDatabase self, int playlist_id, int file_id, int pos) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_addToPlaylistById(self, *args)

    def addToPlaylistByUri(self, *args):
        """addToPlaylistByUri(eMediaDatabase self, int playlist_id, std::string const & uri, int pos, StringMap attributes) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_addToPlaylistByUri(self, *args)

    def updatePlaylistItem(self, *args):
        """updatePlaylistItem(eMediaDatabase self, int playlist_id, StringMap item) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_updatePlaylistItem(self, *args)

    def clearPlaylist(self, *args):
        """clearPlaylist(eMediaDatabase self, int playlist_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_clearPlaylist(self, *args)

    def savePlaylist(self, *args):
        """savePlaylist(eMediaDatabase self, int playlist_id, std::string const & name, int type, StringMapVector items) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_savePlaylist(self, *args)

    def removeFile(self, *args):
        """removeFile(eMediaDatabase self, int file_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_removeFile(self, *args)

    def query(self, *args):
        """
        query(eMediaDatabase self, std::string const & sql, StringList values=stringList(), bool rw=False) -> eMediaDatabaseResultPtr
        query(eMediaDatabase self, std::string const & sql, StringList values=stringList()) -> eMediaDatabaseResultPtr
        query(eMediaDatabase self, std::string const & sql) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_query(self, *args)

    scanStatistics = _swig_property(_enigma.eMediaDatabase_scanStatistics_get, _enigma.eMediaDatabase_scanStatistics_set)
    scanFinished = _swig_property(_enigma.eMediaDatabase_scanFinished_get, _enigma.eMediaDatabase_scanFinished_set)
    insertFinished = _swig_property(_enigma.eMediaDatabase_insertFinished_get, _enigma.eMediaDatabase_insertFinished_set)
    priorityInsertFinished = _swig_property(_enigma.eMediaDatabase_priorityInsertFinished_get, _enigma.eMediaDatabase_priorityInsertFinished_set)
eMediaDatabase.getCurrentScanPath = new_instancemethod(_enigma.eMediaDatabase_getCurrentScanPath,None,eMediaDatabase)
eMediaDatabase.getEnqueuedPaths = new_instancemethod(_enigma.eMediaDatabase_getEnqueuedPaths,None,eMediaDatabase)
eMediaDatabase.addPath = new_instancemethod(_enigma.eMediaDatabase_addPath,None,eMediaDatabase)
eMediaDatabase.rescanPath = new_instancemethod(_enigma.eMediaDatabase_rescanPath,None,eMediaDatabase)
eMediaDatabase.requestScanStatistics = new_instancemethod(_enigma.eMediaDatabase_requestScanStatistics,None,eMediaDatabase)
eMediaDatabase.setParentDirectoryWatched = new_instancemethod(_enigma.eMediaDatabase_setParentDirectoryWatched,None,eMediaDatabase)
eMediaDatabase.deleteParentDirectory = new_instancemethod(_enigma.eMediaDatabase_deleteParentDirectory,None,eMediaDatabase)
eMediaDatabase.getParentDirectories = new_instancemethod(_enigma.eMediaDatabase_getParentDirectories,None,eMediaDatabase)
eMediaDatabase.filterAudio = new_instancemethod(_enigma.eMediaDatabase_filterAudio,None,eMediaDatabase)
eMediaDatabase.filterByAlbum = new_instancemethod(_enigma.eMediaDatabase_filterByAlbum,None,eMediaDatabase)
eMediaDatabase.filterByArtistAlbum = new_instancemethod(_enigma.eMediaDatabase_filterByArtistAlbum,None,eMediaDatabase)
eMediaDatabase.filterByArtist = new_instancemethod(_enigma.eMediaDatabase_filterByArtist,None,eMediaDatabase)
eMediaDatabase.filterByGenre = new_instancemethod(_enigma.eMediaDatabase_filterByGenre,None,eMediaDatabase)
eMediaDatabase.filterByTitle = new_instancemethod(_enigma.eMediaDatabase_filterByTitle,None,eMediaDatabase)
eMediaDatabase.getAllArtists = new_instancemethod(_enigma.eMediaDatabase_getAllArtists,None,eMediaDatabase)
eMediaDatabase.getAllAlbumArtists = new_instancemethod(_enigma.eMediaDatabase_getAllAlbumArtists,None,eMediaDatabase)
eMediaDatabase.getArtists = new_instancemethod(_enigma.eMediaDatabase_getArtists,None,eMediaDatabase)
eMediaDatabase.getAllAlbums = new_instancemethod(_enigma.eMediaDatabase_getAllAlbums,None,eMediaDatabase)
eMediaDatabase.getAlbums = new_instancemethod(_enigma.eMediaDatabase_getAlbums,None,eMediaDatabase)
eMediaDatabase.getAlbumsByArtist = new_instancemethod(_enigma.eMediaDatabase_getAlbumsByArtist,None,eMediaDatabase)
eMediaDatabase.getAlbumsByAlbumArtist = new_instancemethod(_enigma.eMediaDatabase_getAlbumsByAlbumArtist,None,eMediaDatabase)
eMediaDatabase.getAllAudio = new_instancemethod(_enigma.eMediaDatabase_getAllAudio,None,eMediaDatabase)
eMediaDatabase.getAllVideos = new_instancemethod(_enigma.eMediaDatabase_getAllVideos,None,eMediaDatabase)
eMediaDatabase.addRecording = new_instancemethod(_enigma.eMediaDatabase_addRecording,None,eMediaDatabase)
eMediaDatabase.getAllRecordings = new_instancemethod(_enigma.eMediaDatabase_getAllRecordings,None,eMediaDatabase)
eMediaDatabase.getRecordings = new_instancemethod(_enigma.eMediaDatabase_getRecordings,None,eMediaDatabase)
eMediaDatabase.getRecordMeta = new_instancemethod(_enigma.eMediaDatabase_getRecordMeta,None,eMediaDatabase)
eMediaDatabase.setRecordMeta = new_instancemethod(_enigma.eMediaDatabase_setRecordMeta,None,eMediaDatabase)
eMediaDatabase.getRecordEit = new_instancemethod(_enigma.eMediaDatabase_getRecordEit,None,eMediaDatabase)
eMediaDatabase.setRecordEit = new_instancemethod(_enigma.eMediaDatabase_setRecordEit,None,eMediaDatabase)
eMediaDatabase.getFileByPath = new_instancemethod(_enigma.eMediaDatabase_getFileByPath,None,eMediaDatabase)
eMediaDatabase.setFileAttribute = new_instancemethod(_enigma.eMediaDatabase_setFileAttribute,None,eMediaDatabase)
eMediaDatabase.deleteFileAttribute = new_instancemethod(_enigma.eMediaDatabase_deleteFileAttribute,None,eMediaDatabase)
eMediaDatabase.getFileAttributes = new_instancemethod(_enigma.eMediaDatabase_getFileAttributes,None,eMediaDatabase)
eMediaDatabase.getFileAttribute = new_instancemethod(_enigma.eMediaDatabase_getFileAttribute,None,eMediaDatabase)
eMediaDatabase.addPlaylist = new_instancemethod(_enigma.eMediaDatabase_addPlaylist,None,eMediaDatabase)
eMediaDatabase.getPlaylist = new_instancemethod(_enigma.eMediaDatabase_getPlaylist,None,eMediaDatabase)
eMediaDatabase.getPlaylistByName = new_instancemethod(_enigma.eMediaDatabase_getPlaylistByName,None,eMediaDatabase)
eMediaDatabase.getPlaylistItemsById = new_instancemethod(_enigma.eMediaDatabase_getPlaylistItemsById,None,eMediaDatabase)
eMediaDatabase.getPlaylistItemsByName = new_instancemethod(_enigma.eMediaDatabase_getPlaylistItemsByName,None,eMediaDatabase)
eMediaDatabase.getPlaylists = new_instancemethod(_enigma.eMediaDatabase_getPlaylists,None,eMediaDatabase)
eMediaDatabase.addToPlaylistById = new_instancemethod(_enigma.eMediaDatabase_addToPlaylistById,None,eMediaDatabase)
eMediaDatabase.addToPlaylistByUri = new_instancemethod(_enigma.eMediaDatabase_addToPlaylistByUri,None,eMediaDatabase)
eMediaDatabase.updatePlaylistItem = new_instancemethod(_enigma.eMediaDatabase_updatePlaylistItem,None,eMediaDatabase)
eMediaDatabase.clearPlaylist = new_instancemethod(_enigma.eMediaDatabase_clearPlaylist,None,eMediaDatabase)
eMediaDatabase.savePlaylist = new_instancemethod(_enigma.eMediaDatabase_savePlaylist,None,eMediaDatabase)
eMediaDatabase.removeFile = new_instancemethod(_enigma.eMediaDatabase_removeFile,None,eMediaDatabase)
eMediaDatabase.query = new_instancemethod(_enigma.eMediaDatabase_query,None,eMediaDatabase)
eMediaDatabase_swigregister = _enigma.eMediaDatabase_swigregister
eMediaDatabase_swigregister(eMediaDatabase)
eMediaDatabase.FIELD_ID = _enigma.cvar.eMediaDatabase_FIELD_ID
eMediaDatabase.FIELD_FILE_ID = _enigma.cvar.eMediaDatabase_FIELD_FILE_ID
eMediaDatabase.FIELD_DIR_ID = _enigma.cvar.eMediaDatabase_FIELD_DIR_ID
eMediaDatabase.FIELD_ALBUM_ID = _enigma.cvar.eMediaDatabase_FIELD_ALBUM_ID
eMediaDatabase.FIELD_ARTIST_ID = _enigma.cvar.eMediaDatabase_FIELD_ARTIST_ID
eMediaDatabase.FIELD_ALBUM_ARTIST_ID = _enigma.cvar.eMediaDatabase_FIELD_ALBUM_ARTIST_ID
eMediaDatabase.FIELD_GENRE_ID = _enigma.cvar.eMediaDatabase_FIELD_GENRE_ID
eMediaDatabase.FIELD_CODEC_ID = _enigma.cvar.eMediaDatabase_FIELD_CODEC_ID
eMediaDatabase.FIELD_PATH = _enigma.cvar.eMediaDatabase_FIELD_PATH
eMediaDatabase.FIELD_FILENAME = _enigma.cvar.eMediaDatabase_FIELD_FILENAME
eMediaDatabase.FIELD_SIZE = _enigma.cvar.eMediaDatabase_FIELD_SIZE
eMediaDatabase.FIELD_DURATION = _enigma.cvar.eMediaDatabase_FIELD_DURATION
eMediaDatabase.FIELD_POPULARITY = _enigma.cvar.eMediaDatabase_FIELD_POPULARITY
eMediaDatabase.FIELD_LASTPLAYPOS = _enigma.cvar.eMediaDatabase_FIELD_LASTPLAYPOS
eMediaDatabase.FIELD_LASTPLAYED = _enigma.cvar.eMediaDatabase_FIELD_LASTPLAYED
eMediaDatabase.FIELD_LASTMODIFIED = _enigma.cvar.eMediaDatabase_FIELD_LASTMODIFIED
eMediaDatabase.FIELD_LASTUPDATED = _enigma.cvar.eMediaDatabase_FIELD_LASTUPDATED
eMediaDatabase.FIELD_TITLE = _enigma.cvar.eMediaDatabase_FIELD_TITLE
eMediaDatabase.FIELD_TRACK = _enigma.cvar.eMediaDatabase_FIELD_TRACK
eMediaDatabase.FIELD_TRACKS_TOTAL = _enigma.cvar.eMediaDatabase_FIELD_TRACKS_TOTAL
eMediaDatabase.FIELD_DATE = _enigma.cvar.eMediaDatabase_FIELD_DATE
eMediaDatabase.FIELD_COMMENT = _enigma.cvar.eMediaDatabase_FIELD_COMMENT
eMediaDatabase.FIELD_ARTIST = _enigma.cvar.eMediaDatabase_FIELD_ARTIST
eMediaDatabase.FIELD_ALBUM_ARTIST = _enigma.cvar.eMediaDatabase_FIELD_ALBUM_ARTIST
eMediaDatabase.FIELD_ALBUM = _enigma.cvar.eMediaDatabase_FIELD_ALBUM
eMediaDatabase.FIELD_GENRE = _enigma.cvar.eMediaDatabase_FIELD_GENRE
eMediaDatabase.FIELD_CODEC = _enigma.cvar.eMediaDatabase_FIELD_CODEC
eMediaDatabase.FIELD_CODEC_LONG = _enigma.cvar.eMediaDatabase_FIELD_CODEC_LONG
eMediaDatabase.FIELD_WIDTH = _enigma.cvar.eMediaDatabase_FIELD_WIDTH
eMediaDatabase.FIELD_HEIGHT = _enigma.cvar.eMediaDatabase_FIELD_HEIGHT
eMediaDatabase.FIELD_FRAMERATE = _enigma.cvar.eMediaDatabase_FIELD_FRAMERATE
eMediaDatabase.FIELD_HD = _enigma.cvar.eMediaDatabase_FIELD_HD
eMediaDatabase.FIELD_WIDESCREEN = _enigma.cvar.eMediaDatabase_FIELD_WIDESCREEN
eMediaDatabase.FIELD_RECORDING = _enigma.cvar.eMediaDatabase_FIELD_RECORDING
eMediaDatabase.FIELD_PLAYLIST_NAME = _enigma.cvar.eMediaDatabase_FIELD_PLAYLIST_NAME
eMediaDatabase.FIELD_FILE_URI = _enigma.cvar.eMediaDatabase_FIELD_FILE_URI
eMediaDatabase.FIELD_POS = _enigma.cvar.eMediaDatabase_FIELD_POS
eMediaDatabase.FIELD_DESCRIPTION = _enigma.cvar.eMediaDatabase_FIELD_DESCRIPTION
eMediaDatabase.FIELD_SERVICEREFRENCE = _enigma.cvar.eMediaDatabase_FIELD_SERVICEREFRENCE
eMediaDatabase.FIELD_TYPE = _enigma.cvar.eMediaDatabase_FIELD_TYPE
eMediaDatabase.FIELD_NAME = _enigma.cvar.eMediaDatabase_FIELD_NAME

def eMediaDatabase_getInstance():
  """eMediaDatabase_getInstance() -> eMediaDatabase"""
  return _enigma.eMediaDatabase_getInstance()

class eMediaDatabaseResultPtr(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): 
        _enigma.eMediaDatabaseResultPtr_swiginit(self,_enigma.new_eMediaDatabaseResultPtr(*args))
    __swig_destroy__ = _enigma.delete_eMediaDatabaseResultPtr
    def error(self):
        """error(eMediaDatabaseResultPtr self) -> bool"""
        return _enigma.eMediaDatabaseResultPtr_error(self)

    def rowsAffected(self):
        """rowsAffected(eMediaDatabaseResultPtr self) -> int"""
        return _enigma.eMediaDatabaseResultPtr_rowsAffected(self)

    def lastInsertId(self):
        """lastInsertId(eMediaDatabaseResultPtr self) -> int"""
        return _enigma.eMediaDatabaseResultPtr_lastInsertId(self)

    def errorDriverText(self):
        """errorDriverText(eMediaDatabaseResultPtr self) -> std::string"""
        return _enigma.eMediaDatabaseResultPtr_errorDriverText(self)

    def errorDatabaseText(self):
        """errorDatabaseText(eMediaDatabaseResultPtr self) -> std::string"""
        return _enigma.eMediaDatabaseResultPtr_errorDatabaseText(self)

    def data(self):
        """data(eMediaDatabaseResultPtr self) -> StringMapVector"""
        return _enigma.eMediaDatabaseResultPtr_data(self)

eMediaDatabaseResultPtr.__ref__ = new_instancemethod(_enigma.eMediaDatabaseResultPtr___ref__,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr.getPtrString = new_instancemethod(_enigma.eMediaDatabaseResultPtr_getPtrString,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr.__deref__ = new_instancemethod(_enigma.eMediaDatabaseResultPtr___deref__,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr.error = new_instancemethod(_enigma.eMediaDatabaseResultPtr_error,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr.rowsAffected = new_instancemethod(_enigma.eMediaDatabaseResultPtr_rowsAffected,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr.lastInsertId = new_instancemethod(_enigma.eMediaDatabaseResultPtr_lastInsertId,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr.errorDriverText = new_instancemethod(_enigma.eMediaDatabaseResultPtr_errorDriverText,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr.errorDatabaseText = new_instancemethod(_enigma.eMediaDatabaseResultPtr_errorDatabaseText,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr.data = new_instancemethod(_enigma.eMediaDatabaseResultPtr_data,None,eMediaDatabaseResultPtr)
eMediaDatabaseResultPtr_swigregister = _enigma.eMediaDatabaseResultPtr_swigregister
eMediaDatabaseResultPtr_swigregister(eMediaDatabaseResultPtr)

class eNetworkManager(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")
    __repr__ = _swig_repr
    def getInstance():
        """getInstance() -> eNetworkManager"""
        return _enigma.eNetworkManager_getInstance()

    getInstance = staticmethod(getInstance)
    def state(self):
        """state(eNetworkManager self) -> std::string const"""
        return _enigma.eNetworkManager_state(self)

    def offlineMode(self):
        """offlineMode(eNetworkManager self) -> bool"""
        return _enigma.eNetworkManager_offlineMode(self)

    def defaultRoute(self):
        """defaultRoute(eNetworkManager self) -> eNetworkServicePtr"""
        return _enigma.eNetworkManager_defaultRoute(self)

    def setOfflineMode(self, *args):
        """setOfflineMode(eNetworkManager self, bool enabled)"""
        return _enigma.eNetworkManager_setOfflineMode(self, *args)

    def getService(self, *args):
        """getService(eNetworkManager self, std::string const & path) -> eNetworkServicePtr"""
        return _enigma.eNetworkManager_getService(self, *args)

    def getServices(self):
        """getServices(eNetworkManager self) -> eNetworkServicePtrVector"""
        return _enigma.eNetworkManager_getServices(self)

    def getTechnologies(self):
        """getTechnologies(eNetworkManager self) -> eNetworkTechnologyPtrVector"""
        return _enigma.eNetworkManager_getTechnologies(self)

    def sendUserReply(self, *args):
        """sendUserReply(eNetworkManager self, StringMap values)"""
        return _enigma.eNetworkManager_sendUserReply(self, *args)

    def onServicesChanged(self):
        """onServicesChanged(eNetworkManager self)"""
        return _enigma.eNetworkManager_onServicesChanged(self)

    def onTechnologiesChanged(self):
        """onTechnologiesChanged(eNetworkManager self)"""
        return _enigma.eNetworkManager_onTechnologiesChanged(self)

    def online(self):
        """online(eNetworkManager self) -> bool"""
        return _enigma.eNetworkManager_online(self)

    def getUserInputRequestFields(self):
        """getUserInputRequestFields(eNetworkManager self) -> PseudoDict"""
        return _enigma.eNetworkManager_getUserInputRequestFields(self)

    availabilityChanged = _swig_property(_enigma.eNetworkManager_availabilityChanged_get, _enigma.eNetworkManager_availabilityChanged_set)
    stateChanged = _swig_property(_enigma.eNetworkManager_stateChanged_get, _enigma.eNetworkManager_stateChanged_set)
    onlineChanged = _swig_property(_enigma.eNetworkManager_onlineChanged_get, _enigma.eNetworkManager_onlineChanged_set)
    offlineModeChanged = _swig_property(_enigma.eNetworkManager_offlineModeChanged_get, _enigma.eNetworkManager_offlineModeChanged_set)
    technologiesChanged = _swig_property(_enigma.eNetworkManager_technologiesChanged_get, _enigma.eNetworkManager_technologiesChanged_set)
    servicesChanged = _swig_property(_enigma.eNetworkManager_servicesChanged_get, _enigma.eNetworkManager_servicesChanged_set)
    savedServicesChanged = _swig_property(_enigma.eNetworkManager_savedServicesChanged_get, _enigma.eNetworkManager_savedServicesChanged_set)
    defaultRouteChanged = _swig_property(_enigma.eNetworkManager_defaultRouteChanged_get, _enigma.eNetworkManager_defaultRouteChanged_set)
    sessionModeChanged = _swig_property(_enigma.eNetworkManager_sessionModeChanged_get, _enigma.eNetworkManager_sessionModeChanged_set)
    servicesListChanged = _swig_property(_enigma.eNetworkManager_servicesListChanged_get, _enigma.eNetworkManager_servicesListChanged_set)
    serviceAdded = _swig_property(_enigma.eNetworkManager_serviceAdded_get, _enigma.eNetworkManager_serviceAdded_set)
    serviceRemoved = _swig_property(_enigma.eNetworkManager_serviceRemoved_get, _enigma.eNetworkManager_serviceRemoved_set)
    userInputRequested = _swig_property(_enigma.eNetworkManager_userInputRequested_get, _enigma.eNetworkManager_userInputRequested_set)
    userInputCanceled = _swig_property(_enigma.eNetworkManager_userInputCanceled_get, _enigma.eNetworkManager_userInputCanceled_set)
    errorReported = _swig_property(_enigma.eNetworkManager_errorReported_get, _enigma.eNetworkManager_errorReported_set)
    browserRequested = _swig_property(_enigma.eNetworkManager_browserRequested_get, _enigma.eNetworkManager_browserRequested_set)
    userConnectRequested = _swig_property(_enigma.eNetworkManager_userConnectRequested_get, _enigma.eNetworkManager_userConnectRequested_set)
    connectionRequest = _swig_property(_enigma.eNetworkManager_connectionRequest_get, _enigma.eNetworkManager_connectionRequest_set)
eNetworkManager.state = new_instancemethod(_enigma.eNetworkManager_state,None,eNetworkManager)
eNetworkManager.offlineMode = new_instancemethod(_enigma.eNetworkManager_offlineMode,None,eNetworkManager)
eNetworkManager.defaultRoute = new_instancemethod(_enigma.eNetworkManager_defaultRoute,None,eNetworkManager)
eNetworkManager.setOfflineMode = new_instancemethod(_enigma.eNetworkManager_setOfflineMode,None,eNetworkManager)
eNetworkManager.getService = new_instancemethod(_enigma.eNetworkManager_getService,None,eNetworkManager)
eNetworkManager.getServices = new_instancemethod(_enigma.eNetworkManager_getServices,None,eNetworkManager)
eNetworkManager.getTechnologies = new_instancemethod(_enigma.eNetworkManager_getTechnologies,None,eNetworkManager)
eNetworkManager.sendUserReply = new_instancemethod(_enigma.eNetworkManager_sendUserReply,None,eNetworkManager)
eNetworkManager.onServicesChanged = new_instancemethod(_enigma.eNetworkManager_onServicesChanged,None,eNetworkManager)
eNetworkManager.onTechnologiesChanged = new_instancemethod(_enigma.eNetworkManager_onTechnologiesChanged,None,eNetworkManager)
eNetworkManager.online = new_instancemethod(_enigma.eNetworkManager_online,None,eNetworkManager)
eNetworkManager.getUserInputRequestFields = new_instancemethod(_enigma.eNetworkManager_getUserInputRequestFields,None,eNetworkManager)
eNetworkManager_swigregister = _enigma.eNetworkManager_swigregister
eNetworkManager_swigregister(eNetworkManager)
eNetworkManager.STATE_IDLE = _enigma.cvar.eNetworkManager_STATE_IDLE
eNetworkManager.STATE_OFFLINE = _enigma.cvar.eNetworkManager_STATE_OFFLINE
eNetworkManager.STATE_ONLINE = _enigma.cvar.eNetworkManager_STATE_ONLINE
eNetworkManager.STATE_READY = _enigma.cvar.eNetworkManager_STATE_READY
eNetworkManager.STATE_FAILURE = _enigma.cvar.eNetworkManager_STATE_FAILURE

def eNetworkManager_getInstance():
  """eNetworkManager_getInstance() -> eNetworkManager"""
  return _enigma.eNetworkManager_getInstance()

class eNetworkService(iObject):
    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 name(self):
        """name(eNetworkService self) -> std::string const"""
        return _enigma.eNetworkService_name(self)

    def type(self):
        """type(eNetworkService self) -> std::string const"""
        return _enigma.eNetworkService_type(self)

    def state(self):
        """state(eNetworkService self) -> std::string const"""
        return _enigma.eNetworkService_state(self)

    def error(self):
        """error(eNetworkService self) -> std::string const"""
        return _enigma.eNetworkService_error(self)

    def security(self):
        """security(eNetworkService self) -> StringList"""
        return _enigma.eNetworkService_security(self)

    def autoConnect(self):
        """autoConnect(eNetworkService self) -> bool"""
        return _enigma.eNetworkService_autoConnect(self)

    def strength(self):
        """strength(eNetworkService self) -> unsigned int"""
        return _enigma.eNetworkService_strength(self)

    def favorite(self):
        """favorite(eNetworkService self) -> bool"""
        return _enigma.eNetworkService_favorite(self)

    def path(self):
        """path(eNetworkService self) -> std::string const"""
        return _enigma.eNetworkService_path(self)

    def ipv4(self):
        """ipv4(eNetworkService self) -> PseudoDict"""
        return _enigma.eNetworkService_ipv4(self)

    def ipv4Config(self):
        """ipv4Config(eNetworkService self) -> PseudoDict"""
        return _enigma.eNetworkService_ipv4Config(self)

    def ipv6(self):
        """ipv6(eNetworkService self) -> PseudoDict"""
        return _enigma.eNetworkService_ipv6(self)

    def ipv6Config(self):
        """ipv6Config(eNetworkService self) -> PseudoDict"""
        return _enigma.eNetworkService_ipv6Config(self)

    def nameservers(self):
        """nameservers(eNetworkService self) -> StringList"""
        return _enigma.eNetworkService_nameservers(self)

    def nameserversConfig(self):
        """nameserversConfig(eNetworkService self) -> StringList"""
        return _enigma.eNetworkService_nameserversConfig(self)

    def domains(self):
        """domains(eNetworkService self) -> StringList"""
        return _enigma.eNetworkService_domains(self)

    def domainsConfig(self):
        """domainsConfig(eNetworkService self) -> StringList"""
        return _enigma.eNetworkService_domainsConfig(self)

    def timeservers(self):
        """timeservers(eNetworkService self) -> StringList"""
        return _enigma.eNetworkService_timeservers(self)

    def timeserversConfig(self):
        """timeserversConfig(eNetworkService self) -> StringList"""
        return _enigma.eNetworkService_timeserversConfig(self)

    def proxy(self):
        """proxy(eNetworkService self) -> PseudoDict"""
        return _enigma.eNetworkService_proxy(self)

    def proxyConfig(self):
        """proxyConfig(eNetworkService self) -> PseudoDict"""
        return _enigma.eNetworkService_proxyConfig(self)

    def ethernet(self):
        """ethernet(eNetworkService self) -> PseudoDict"""
        return _enigma.eNetworkService_ethernet(self)

    def roaming(self):
        """roaming(eNetworkService self) -> bool"""
        return _enigma.eNetworkService_roaming(self)

    def setPath(self, *args):
        """setPath(eNetworkService self, std::string const & path)"""
        return _enigma.eNetworkService_setPath(self, *args)

    def updateProperties(self, *args):
        """updateProperties(eNetworkService self, PseudoDict properties)"""
        return _enigma.eNetworkService_updateProperties(self, *args)

    def connected(self):
        """connected(eNetworkService self) -> bool"""
        return _enigma.eNetworkService_connected(self)

    def requestConnect(self):
        """requestConnect(eNetworkService self)"""
        return _enigma.eNetworkService_requestConnect(self)

    def requestDisconnect(self):
        """requestDisconnect(eNetworkService self)"""
        return _enigma.eNetworkService_requestDisconnect(self)

    def remove(self):
        """remove(eNetworkService self)"""
        return _enigma.eNetworkService_remove(self)

    def setAutoConnect(self, *args):
        """setAutoConnect(eNetworkService self, bool const autoconnect)"""
        return _enigma.eNetworkService_setAutoConnect(self, *args)

    def setIpv4Config(self, *args):
        """setIpv4Config(eNetworkService self, StringMap ipv4)"""
        return _enigma.eNetworkService_setIpv4Config(self, *args)

    def setIpv6Config(self, *args):
        """setIpv6Config(eNetworkService self, StringMap ipv6)"""
        return _enigma.eNetworkService_setIpv6Config(self, *args)

    def setNameserversConfig(self, *args):
        """setNameserversConfig(eNetworkService self, StringList nameservers)"""
        return _enigma.eNetworkService_setNameserversConfig(self, *args)

    def setDomainsConfig(self, *args):
        """setDomainsConfig(eNetworkService self, StringList domains)"""
        return _enigma.eNetworkService_setDomainsConfig(self, *args)

    def setProxyConfig(self, *args):
        """setProxyConfig(eNetworkService self, StringMap proxy)"""
        return _enigma.eNetworkService_setProxyConfig(self, *args)

    def resetCounters(self):
        """resetCounters(eNetworkService self)"""
        return _enigma.eNetworkService_resetCounters(self)

    nameChanged = _swig_property(_enigma.eNetworkService_nameChanged_get, _enigma.eNetworkService_nameChanged_set)
    stateChanged = _swig_property(_enigma.eNetworkService_stateChanged_get, _enigma.eNetworkService_stateChanged_set)
    errorChanged = _swig_property(_enigma.eNetworkService_errorChanged_get, _enigma.eNetworkService_errorChanged_set)
    securityChanged = _swig_property(_enigma.eNetworkService_securityChanged_get, _enigma.eNetworkService_securityChanged_set)
    strengthChanged = _swig_property(_enigma.eNetworkService_strengthChanged_get, _enigma.eNetworkService_strengthChanged_set)
    favoriteChanged = _swig_property(_enigma.eNetworkService_favoriteChanged_get, _enigma.eNetworkService_favoriteChanged_set)
    autoConnectChanged = _swig_property(_enigma.eNetworkService_autoConnectChanged_get, _enigma.eNetworkService_autoConnectChanged_set)
    pathChanged = _swig_property(_enigma.eNetworkService_pathChanged_get, _enigma.eNetworkService_pathChanged_set)
    ipv4Changed = _swig_property(_enigma.eNetworkService_ipv4Changed_get, _enigma.eNetworkService_ipv4Changed_set)
    ipv4ConfigChanged = _swig_property(_enigma.eNetworkService_ipv4ConfigChanged_get, _enigma.eNetworkService_ipv4ConfigChanged_set)
    ipv6Changed = _swig_property(_enigma.eNetworkService_ipv6Changed_get, _enigma.eNetworkService_ipv6Changed_set)
    ipv6ConfigChanged = _swig_property(_enigma.eNetworkService_ipv6ConfigChanged_get, _enigma.eNetworkService_ipv6ConfigChanged_set)
    nameserversChanged = _swig_property(_enigma.eNetworkService_nameserversChanged_get, _enigma.eNetworkService_nameserversChanged_set)
    nameserversConfigChanged = _swig_property(_enigma.eNetworkService_nameserversConfigChanged_get, _enigma.eNetworkService_nameserversConfigChanged_set)
    domainsChanged = _swig_property(_enigma.eNetworkService_domainsChanged_get, _enigma.eNetworkService_domainsChanged_set)
    domainsConfigChanged = _swig_property(_enigma.eNetworkService_domainsConfigChanged_get, _enigma.eNetworkService_domainsConfigChanged_set)
    proxyChanged = _swig_property(_enigma.eNetworkService_proxyChanged_get, _enigma.eNetworkService_proxyChanged_set)
    proxyConfigChanged = _swig_property(_enigma.eNetworkService_proxyConfigChanged_get, _enigma.eNetworkService_proxyConfigChanged_set)
    ethernetChanged = _swig_property(_enigma.eNetworkService_ethernetChanged_get, _enigma.eNetworkService_ethernetChanged_set)
    connectRequestFailed = _swig_property(_enigma.eNetworkService_connectRequestFailed_get, _enigma.eNetworkService_connectRequestFailed_set)
    typeChanged = _swig_property(_enigma.eNetworkService_typeChanged_get, _enigma.eNetworkService_typeChanged_set)
    roamingChanged = _swig_property(_enigma.eNetworkService_roamingChanged_get, _enigma.eNetworkService_roamingChanged_set)
    serviceConnectionStarted = _swig_property(_enigma.eNetworkService_serviceConnectionStarted_get, _enigma.eNetworkService_serviceConnectionStarted_set)
    serviceDisconnectionStarted = _swig_property(_enigma.eNetworkService_serviceDisconnectionStarted_get, _enigma.eNetworkService_serviceDisconnectionStarted_set)
    connectedChanged = _swig_property(_enigma.eNetworkService_connectedChanged_get, _enigma.eNetworkService_connectedChanged_set)
eNetworkService.name = new_instancemethod(_enigma.eNetworkService_name,None,eNetworkService)
eNetworkService.type = new_instancemethod(_enigma.eNetworkService_type,None,eNetworkService)
eNetworkService.state = new_instancemethod(_enigma.eNetworkService_state,None,eNetworkService)
eNetworkService.error = new_instancemethod(_enigma.eNetworkService_error,None,eNetworkService)
eNetworkService.security = new_instancemethod(_enigma.eNetworkService_security,None,eNetworkService)
eNetworkService.autoConnect = new_instancemethod(_enigma.eNetworkService_autoConnect,None,eNetworkService)
eNetworkService.strength = new_instancemethod(_enigma.eNetworkService_strength,None,eNetworkService)
eNetworkService.favorite = new_instancemethod(_enigma.eNetworkService_favorite,None,eNetworkService)
eNetworkService.path = new_instancemethod(_enigma.eNetworkService_path,None,eNetworkService)
eNetworkService.ipv4 = new_instancemethod(_enigma.eNetworkService_ipv4,None,eNetworkService)
eNetworkService.ipv4Config = new_instancemethod(_enigma.eNetworkService_ipv4Config,None,eNetworkService)
eNetworkService.ipv6 = new_instancemethod(_enigma.eNetworkService_ipv6,None,eNetworkService)
eNetworkService.ipv6Config = new_instancemethod(_enigma.eNetworkService_ipv6Config,None,eNetworkService)
eNetworkService.nameservers = new_instancemethod(_enigma.eNetworkService_nameservers,None,eNetworkService)
eNetworkService.nameserversConfig = new_instancemethod(_enigma.eNetworkService_nameserversConfig,None,eNetworkService)
eNetworkService.domains = new_instancemethod(_enigma.eNetworkService_domains,None,eNetworkService)
eNetworkService.domainsConfig = new_instancemethod(_enigma.eNetworkService_domainsConfig,None,eNetworkService)
eNetworkService.timeservers = new_instancemethod(_enigma.eNetworkService_timeservers,None,eNetworkService)
eNetworkService.timeserversConfig = new_instancemethod(_enigma.eNetworkService_timeserversConfig,None,eNetworkService)
eNetworkService.proxy = new_instancemethod(_enigma.eNetworkService_proxy,None,eNetworkService)
eNetworkService.proxyConfig = new_instancemethod(_enigma.eNetworkService_proxyConfig,None,eNetworkService)
eNetworkService.ethernet = new_instancemethod(_enigma.eNetworkService_ethernet,None,eNetworkService)
eNetworkService.roaming = new_instancemethod(_enigma.eNetworkService_roaming,None,eNetworkService)
eNetworkService.setPath = new_instancemethod(_enigma.eNetworkService_setPath,None,eNetworkService)
eNetworkService.updateProperties = new_instancemethod(_enigma.eNetworkService_updateProperties,None,eNetworkService)
eNetworkService.connected = new_instancemethod(_enigma.eNetworkService_connected,None,eNetworkService)
eNetworkService.requestConnect = new_instancemethod(_enigma.eNetworkService_requestConnect,None,eNetworkService)
eNetworkService.requestDisconnect = new_instancemethod(_enigma.eNetworkService_requestDisconnect,None,eNetworkService)
eNetworkService.remove = new_instancemethod(_enigma.eNetworkService_remove,None,eNetworkService)
eNetworkService.setAutoConnect = new_instancemethod(_enigma.eNetworkService_setAutoConnect,None,eNetworkService)
eNetworkService.setIpv4Config = new_instancemethod(_enigma.eNetworkService_setIpv4Config,None,eNetworkService)
eNetworkService.setIpv6Config = new_instancemethod(_enigma.eNetworkService_setIpv6Config,None,eNetworkService)
eNetworkService.setNameserversConfig = new_instancemethod(_enigma.eNetworkService_setNameserversConfig,None,eNetworkService)
eNetworkService.setDomainsConfig = new_instancemethod(_enigma.eNetworkService_setDomainsConfig,None,eNetworkService)
eNetworkService.setProxyConfig = new_instancemethod(_enigma.eNetworkService_setProxyConfig,None,eNetworkService)
eNetworkService.resetCounters = new_instancemethod(_enigma.eNetworkService_resetCounters,None,eNetworkService)
eNetworkService_swigregister = _enigma.eNetworkService_swigregister
eNetworkService_swigregister(eNetworkService)
eNetworkService.KEY_METHOD = _enigma.cvar.eNetworkService_KEY_METHOD
eNetworkService.KEY_ADDRESS = _enigma.cvar.eNetworkService_KEY_ADDRESS
eNetworkService.KEY_NETMASK = _enigma.cvar.eNetworkService_KEY_NETMASK
eNetworkService.KEY_GATEWAY = _enigma.cvar.eNetworkService_KEY_GATEWAY
eNetworkService.KEY_PREFIX_LENGTH = _enigma.cvar.eNetworkService_KEY_PREFIX_LENGTH
eNetworkService.KEY_PRIVACY = _enigma.cvar.eNetworkService_KEY_PRIVACY
eNetworkService.KEY_INTERFACE = _enigma.cvar.eNetworkService_KEY_INTERFACE
eNetworkService.METHOD_DHCP = _enigma.cvar.eNetworkService_METHOD_DHCP
eNetworkService.METHOD_AUTO = _enigma.cvar.eNetworkService_METHOD_AUTO
eNetworkService.METHOD_6TO4 = _enigma.cvar.eNetworkService_METHOD_6TO4
eNetworkService.METHOD_FIXED = _enigma.cvar.eNetworkService_METHOD_FIXED
eNetworkService.METHOD_MANUAL = _enigma.cvar.eNetworkService_METHOD_MANUAL
eNetworkService.METHOD_OFF = _enigma.cvar.eNetworkService_METHOD_OFF
eNetworkService.TYPE_ETHERNET = _enigma.cvar.eNetworkService_TYPE_ETHERNET
eNetworkService.TYPE_WIFI = _enigma.cvar.eNetworkService_TYPE_WIFI
eNetworkService.IPV6_PRIVACY_DISABLED = _enigma.cvar.eNetworkService_IPV6_PRIVACY_DISABLED
eNetworkService.IPV6_PRIVACY_PREFERRED = _enigma.cvar.eNetworkService_IPV6_PRIVACY_PREFERRED
eNetworkService.IPV6_PRIVACY_ENABLED = _enigma.cvar.eNetworkService_IPV6_PRIVACY_ENABLED

class eNetworkServicePtr(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): 
        _enigma.eNetworkServicePtr_swiginit(self,_enigma.new_eNetworkServicePtr(*args))
    __swig_destroy__ = _enigma.delete_eNetworkServicePtr
    KEY_METHOD = _swig_property(_enigma.eNetworkServicePtr_KEY_METHOD_get)
    KEY_ADDRESS = _swig_property(_enigma.eNetworkServicePtr_KEY_ADDRESS_get)
    KEY_NETMASK = _swig_property(_enigma.eNetworkServicePtr_KEY_NETMASK_get)
    KEY_GATEWAY = _swig_property(_enigma.eNetworkServicePtr_KEY_GATEWAY_get)
    KEY_PREFIX_LENGTH = _swig_property(_enigma.eNetworkServicePtr_KEY_PREFIX_LENGTH_get)
    KEY_PRIVACY = _swig_property(_enigma.eNetworkServicePtr_KEY_PRIVACY_get)
    KEY_INTERFACE = _swig_property(_enigma.eNetworkServicePtr_KEY_INTERFACE_get)
    METHOD_DHCP = _swig_property(_enigma.eNetworkServicePtr_METHOD_DHCP_get)
    METHOD_AUTO = _swig_property(_enigma.eNetworkServicePtr_METHOD_AUTO_get)
    METHOD_6TO4 = _swig_property(_enigma.eNetworkServicePtr_METHOD_6TO4_get)
    METHOD_FIXED = _swig_property(_enigma.eNetworkServicePtr_METHOD_FIXED_get)
    METHOD_MANUAL = _swig_property(_enigma.eNetworkServicePtr_METHOD_MANUAL_get)
    METHOD_OFF = _swig_property(_enigma.eNetworkServicePtr_METHOD_OFF_get)
    TYPE_ETHERNET = _swig_property(_enigma.eNetworkServicePtr_TYPE_ETHERNET_get)
    TYPE_WIFI = _swig_property(_enigma.eNetworkServicePtr_TYPE_WIFI_get)
    IPV6_PRIVACY_DISABLED = _swig_property(_enigma.eNetworkServicePtr_IPV6_PRIVACY_DISABLED_get)
    IPV6_PRIVACY_PREFERRED = _swig_property(_enigma.eNetworkServicePtr_IPV6_PRIVACY_PREFERRED_get)
    IPV6_PRIVACY_ENABLED = _swig_property(_enigma.eNetworkServicePtr_IPV6_PRIVACY_ENABLED_get)
    def name(self):
        """name(eNetworkServicePtr self) -> std::string const"""
        return _enigma.eNetworkServicePtr_name(self)

    def type(self):
        """type(eNetworkServicePtr self) -> std::string const"""
        return _enigma.eNetworkServicePtr_type(self)

    def state(self):
        """state(eNetworkServicePtr self) -> std::string const"""
        return _enigma.eNetworkServicePtr_state(self)

    def error(self):
        """error(eNetworkServicePtr self) -> std::string const"""
        return _enigma.eNetworkServicePtr_error(self)

    def security(self):
        """security(eNetworkServicePtr self) -> StringList"""
        return _enigma.eNetworkServicePtr_security(self)

    def autoConnect(self):
        """autoConnect(eNetworkServicePtr self) -> bool"""
        return _enigma.eNetworkServicePtr_autoConnect(self)

    def strength(self):
        """strength(eNetworkServicePtr self) -> unsigned int"""
        return _enigma.eNetworkServicePtr_strength(self)

    def favorite(self):
        """favorite(eNetworkServicePtr self) -> bool"""
        return _enigma.eNetworkServicePtr_favorite(self)

    def path(self):
        """path(eNetworkServicePtr self) -> std::string const"""
        return _enigma.eNetworkServicePtr_path(self)

    def ipv4(self):
        """ipv4(eNetworkServicePtr self) -> PseudoDict"""
        return _enigma.eNetworkServicePtr_ipv4(self)

    def ipv4Config(self):
        """ipv4Config(eNetworkServicePtr self) -> PseudoDict"""
        return _enigma.eNetworkServicePtr_ipv4Config(self)

    def ipv6(self):
        """ipv6(eNetworkServicePtr self) -> PseudoDict"""
        return _enigma.eNetworkServicePtr_ipv6(self)

    def ipv6Config(self):
        """ipv6Config(eNetworkServicePtr self) -> PseudoDict"""
        return _enigma.eNetworkServicePtr_ipv6Config(self)

    def nameservers(self):
        """nameservers(eNetworkServicePtr self) -> StringList"""
        return _enigma.eNetworkServicePtr_nameservers(self)

    def nameserversConfig(self):
        """nameserversConfig(eNetworkServicePtr self) -> StringList"""
        return _enigma.eNetworkServicePtr_nameserversConfig(self)

    def domains(self):
        """domains(eNetworkServicePtr self) -> StringList"""
        return _enigma.eNetworkServicePtr_domains(self)

    def domainsConfig(self):
        """domainsConfig(eNetworkServicePtr self) -> StringList"""
        return _enigma.eNetworkServicePtr_domainsConfig(self)

    def timeservers(self):
        """timeservers(eNetworkServicePtr self) -> StringList"""
        return _enigma.eNetworkServicePtr_timeservers(self)

    def timeserversConfig(self):
        """timeserversConfig(eNetworkServicePtr self) -> StringList"""
        return _enigma.eNetworkServicePtr_timeserversConfig(self)

    def proxy(self):
        """proxy(eNetworkServicePtr self) -> PseudoDict"""
        return _enigma.eNetworkServicePtr_proxy(self)

    def proxyConfig(self):
        """proxyConfig(eNetworkServicePtr self) -> PseudoDict"""
        return _enigma.eNetworkServicePtr_proxyConfig(self)

    def ethernet(self):
        """ethernet(eNetworkServicePtr self) -> PseudoDict"""
        return _enigma.eNetworkServicePtr_ethernet(self)

    def roaming(self):
        """roaming(eNetworkServicePtr self) -> bool"""
        return _enigma.eNetworkServicePtr_roaming(self)

    def setPath(self, *args):
        """setPath(eNetworkServicePtr self, std::string const & path)"""
        return _enigma.eNetworkServicePtr_setPath(self, *args)

    def updateProperties(self, *args):
        """updateProperties(eNetworkServicePtr self, PseudoDict properties)"""
        return _enigma.eNetworkServicePtr_updateProperties(self, *args)

    def connected(self):
        """connected(eNetworkServicePtr self) -> bool"""
        return _enigma.eNetworkServicePtr_connected(self)

    def requestConnect(self):
        """requestConnect(eNetworkServicePtr self)"""
        return _enigma.eNetworkServicePtr_requestConnect(self)

    def requestDisconnect(self):
        """requestDisconnect(eNetworkServicePtr self)"""
        return _enigma.eNetworkServicePtr_requestDisconnect(self)

    def remove(self):
        """remove(eNetworkServicePtr self)"""
        return _enigma.eNetworkServicePtr_remove(self)

    def setAutoConnect(self, *args):
        """setAutoConnect(eNetworkServicePtr self, bool const autoconnect)"""
        return _enigma.eNetworkServicePtr_setAutoConnect(self, *args)

    def setIpv4Config(self, *args):
        """setIpv4Config(eNetworkServicePtr self, StringMap ipv4)"""
        return _enigma.eNetworkServicePtr_setIpv4Config(self, *args)

    def setIpv6Config(self, *args):
        """setIpv6Config(eNetworkServicePtr self, StringMap ipv6)"""
        return _enigma.eNetworkServicePtr_setIpv6Config(self, *args)

    def setNameserversConfig(self, *args):
        """setNameserversConfig(eNetworkServicePtr self, StringList nameservers)"""
        return _enigma.eNetworkServicePtr_setNameserversConfig(self, *args)

    def setDomainsConfig(self, *args):
        """setDomainsConfig(eNetworkServicePtr self, StringList domains)"""
        return _enigma.eNetworkServicePtr_setDomainsConfig(self, *args)

    def setProxyConfig(self, *args):
        """setProxyConfig(eNetworkServicePtr self, StringMap proxy)"""
        return _enigma.eNetworkServicePtr_setProxyConfig(self, *args)

    def resetCounters(self):
        """resetCounters(eNetworkServicePtr self)"""
        return _enigma.eNetworkServicePtr_resetCounters(self)

    nameChanged = _swig_property(_enigma.eNetworkServicePtr_nameChanged_get, _enigma.eNetworkServicePtr_nameChanged_set)
    stateChanged = _swig_property(_enigma.eNetworkServicePtr_stateChanged_get, _enigma.eNetworkServicePtr_stateChanged_set)
    errorChanged = _swig_property(_enigma.eNetworkServicePtr_errorChanged_get, _enigma.eNetworkServicePtr_errorChanged_set)
    securityChanged = _swig_property(_enigma.eNetworkServicePtr_securityChanged_get, _enigma.eNetworkServicePtr_securityChanged_set)
    strengthChanged = _swig_property(_enigma.eNetworkServicePtr_strengthChanged_get, _enigma.eNetworkServicePtr_strengthChanged_set)
    favoriteChanged = _swig_property(_enigma.eNetworkServicePtr_favoriteChanged_get, _enigma.eNetworkServicePtr_favoriteChanged_set)
    autoConnectChanged = _swig_property(_enigma.eNetworkServicePtr_autoConnectChanged_get, _enigma.eNetworkServicePtr_autoConnectChanged_set)
    pathChanged = _swig_property(_enigma.eNetworkServicePtr_pathChanged_get, _enigma.eNetworkServicePtr_pathChanged_set)
    ipv4Changed = _swig_property(_enigma.eNetworkServicePtr_ipv4Changed_get, _enigma.eNetworkServicePtr_ipv4Changed_set)
    ipv4ConfigChanged = _swig_property(_enigma.eNetworkServicePtr_ipv4ConfigChanged_get, _enigma.eNetworkServicePtr_ipv4ConfigChanged_set)
    ipv6Changed = _swig_property(_enigma.eNetworkServicePtr_ipv6Changed_get, _enigma.eNetworkServicePtr_ipv6Changed_set)
    ipv6ConfigChanged = _swig_property(_enigma.eNetworkServicePtr_ipv6ConfigChanged_get, _enigma.eNetworkServicePtr_ipv6ConfigChanged_set)
    nameserversChanged = _swig_property(_enigma.eNetworkServicePtr_nameserversChanged_get, _enigma.eNetworkServicePtr_nameserversChanged_set)
    nameserversConfigChanged = _swig_property(_enigma.eNetworkServicePtr_nameserversConfigChanged_get, _enigma.eNetworkServicePtr_nameserversConfigChanged_set)
    domainsChanged = _swig_property(_enigma.eNetworkServicePtr_domainsChanged_get, _enigma.eNetworkServicePtr_domainsChanged_set)
    domainsConfigChanged = _swig_property(_enigma.eNetworkServicePtr_domainsConfigChanged_get, _enigma.eNetworkServicePtr_domainsConfigChanged_set)
    proxyChanged = _swig_property(_enigma.eNetworkServicePtr_proxyChanged_get, _enigma.eNetworkServicePtr_proxyChanged_set)
    proxyConfigChanged = _swig_property(_enigma.eNetworkServicePtr_proxyConfigChanged_get, _enigma.eNetworkServicePtr_proxyConfigChanged_set)
    ethernetChanged = _swig_property(_enigma.eNetworkServicePtr_ethernetChanged_get, _enigma.eNetworkServicePtr_ethernetChanged_set)
    connectRequestFailed = _swig_property(_enigma.eNetworkServicePtr_connectRequestFailed_get, _enigma.eNetworkServicePtr_connectRequestFailed_set)
    typeChanged = _swig_property(_enigma.eNetworkServicePtr_typeChanged_get, _enigma.eNetworkServicePtr_typeChanged_set)
    roamingChanged = _swig_property(_enigma.eNetworkServicePtr_roamingChanged_get, _enigma.eNetworkServicePtr_roamingChanged_set)
    serviceConnectionStarted = _swig_property(_enigma.eNetworkServicePtr_serviceConnectionStarted_get, _enigma.eNetworkServicePtr_serviceConnectionStarted_set)
    serviceDisconnectionStarted = _swig_property(_enigma.eNetworkServicePtr_serviceDisconnectionStarted_get, _enigma.eNetworkServicePtr_serviceDisconnectionStarted_set)
    connectedChanged = _swig_property(_enigma.eNetworkServicePtr_connectedChanged_get, _enigma.eNetworkServicePtr_connectedChanged_set)
eNetworkServicePtr.__ref__ = new_instancemethod(_enigma.eNetworkServicePtr___ref__,None,eNetworkServicePtr)
eNetworkServicePtr.getPtrString = new_instancemethod(_enigma.eNetworkServicePtr_getPtrString,None,eNetworkServicePtr)
eNetworkServicePtr.__deref__ = new_instancemethod(_enigma.eNetworkServicePtr___deref__,None,eNetworkServicePtr)
eNetworkServicePtr.name = new_instancemethod(_enigma.eNetworkServicePtr_name,None,eNetworkServicePtr)
eNetworkServicePtr.type = new_instancemethod(_enigma.eNetworkServicePtr_type,None,eNetworkServicePtr)
eNetworkServicePtr.state = new_instancemethod(_enigma.eNetworkServicePtr_state,None,eNetworkServicePtr)
eNetworkServicePtr.error = new_instancemethod(_enigma.eNetworkServicePtr_error,None,eNetworkServicePtr)
eNetworkServicePtr.security = new_instancemethod(_enigma.eNetworkServicePtr_security,None,eNetworkServicePtr)
eNetworkServicePtr.autoConnect = new_instancemethod(_enigma.eNetworkServicePtr_autoConnect,None,eNetworkServicePtr)
eNetworkServicePtr.strength = new_instancemethod(_enigma.eNetworkServicePtr_strength,None,eNetworkServicePtr)
eNetworkServicePtr.favorite = new_instancemethod(_enigma.eNetworkServicePtr_favorite,None,eNetworkServicePtr)
eNetworkServicePtr.path = new_instancemethod(_enigma.eNetworkServicePtr_path,None,eNetworkServicePtr)
eNetworkServicePtr.ipv4 = new_instancemethod(_enigma.eNetworkServicePtr_ipv4,None,eNetworkServicePtr)
eNetworkServicePtr.ipv4Config = new_instancemethod(_enigma.eNetworkServicePtr_ipv4Config,None,eNetworkServicePtr)
eNetworkServicePtr.ipv6 = new_instancemethod(_enigma.eNetworkServicePtr_ipv6,None,eNetworkServicePtr)
eNetworkServicePtr.ipv6Config = new_instancemethod(_enigma.eNetworkServicePtr_ipv6Config,None,eNetworkServicePtr)
eNetworkServicePtr.nameservers = new_instancemethod(_enigma.eNetworkServicePtr_nameservers,None,eNetworkServicePtr)
eNetworkServicePtr.nameserversConfig = new_instancemethod(_enigma.eNetworkServicePtr_nameserversConfig,None,eNetworkServicePtr)
eNetworkServicePtr.domains = new_instancemethod(_enigma.eNetworkServicePtr_domains,None,eNetworkServicePtr)
eNetworkServicePtr.domainsConfig = new_instancemethod(_enigma.eNetworkServicePtr_domainsConfig,None,eNetworkServicePtr)
eNetworkServicePtr.timeservers = new_instancemethod(_enigma.eNetworkServicePtr_timeservers,None,eNetworkServicePtr)
eNetworkServicePtr.timeserversConfig = new_instancemethod(_enigma.eNetworkServicePtr_timeserversConfig,None,eNetworkServicePtr)
eNetworkServicePtr.proxy = new_instancemethod(_enigma.eNetworkServicePtr_proxy,None,eNetworkServicePtr)
eNetworkServicePtr.proxyConfig = new_instancemethod(_enigma.eNetworkServicePtr_proxyConfig,None,eNetworkServicePtr)
eNetworkServicePtr.ethernet = new_instancemethod(_enigma.eNetworkServicePtr_ethernet,None,eNetworkServicePtr)
eNetworkServicePtr.roaming = new_instancemethod(_enigma.eNetworkServicePtr_roaming,None,eNetworkServicePtr)
eNetworkServicePtr.setPath = new_instancemethod(_enigma.eNetworkServicePtr_setPath,None,eNetworkServicePtr)
eNetworkServicePtr.updateProperties = new_instancemethod(_enigma.eNetworkServicePtr_updateProperties,None,eNetworkServicePtr)
eNetworkServicePtr.connected = new_instancemethod(_enigma.eNetworkServicePtr_connected,None,eNetworkServicePtr)
eNetworkServicePtr.requestConnect = new_instancemethod(_enigma.eNetworkServicePtr_requestConnect,None,eNetworkServicePtr)
eNetworkServicePtr.requestDisconnect = new_instancemethod(_enigma.eNetworkServicePtr_requestDisconnect,None,eNetworkServicePtr)
eNetworkServicePtr.remove = new_instancemethod(_enigma.eNetworkServicePtr_remove,None,eNetworkServicePtr)
eNetworkServicePtr.setAutoConnect = new_instancemethod(_enigma.eNetworkServicePtr_setAutoConnect,None,eNetworkServicePtr)
eNetworkServicePtr.setIpv4Config = new_instancemethod(_enigma.eNetworkServicePtr_setIpv4Config,None,eNetworkServicePtr)
eNetworkServicePtr.setIpv6Config = new_instancemethod(_enigma.eNetworkServicePtr_setIpv6Config,None,eNetworkServicePtr)
eNetworkServicePtr.setNameserversConfig = new_instancemethod(_enigma.eNetworkServicePtr_setNameserversConfig,None,eNetworkServicePtr)
eNetworkServicePtr.setDomainsConfig = new_instancemethod(_enigma.eNetworkServicePtr_setDomainsConfig,None,eNetworkServicePtr)
eNetworkServicePtr.setProxyConfig = new_instancemethod(_enigma.eNetworkServicePtr_setProxyConfig,None,eNetworkServicePtr)
eNetworkServicePtr.resetCounters = new_instancemethod(_enigma.eNetworkServicePtr_resetCounters,None,eNetworkServicePtr)
eNetworkServicePtr_swigregister = _enigma.eNetworkServicePtr_swigregister
eNetworkServicePtr_swigregister(eNetworkServicePtr)

class eNetworkServicePtrVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.eNetworkServicePtrVector_swiginit(self,_enigma.new_eNetworkServicePtrVector(*args))
    __swig_destroy__ = _enigma.delete_eNetworkServicePtrVector
eNetworkServicePtrVector.iterator = new_instancemethod(_enigma.eNetworkServicePtrVector_iterator,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__nonzero__ = new_instancemethod(_enigma.eNetworkServicePtrVector___nonzero__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__bool__ = new_instancemethod(_enigma.eNetworkServicePtrVector___bool__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__len__ = new_instancemethod(_enigma.eNetworkServicePtrVector___len__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.pop = new_instancemethod(_enigma.eNetworkServicePtrVector_pop,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__getslice__ = new_instancemethod(_enigma.eNetworkServicePtrVector___getslice__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__setslice__ = new_instancemethod(_enigma.eNetworkServicePtrVector___setslice__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__delslice__ = new_instancemethod(_enigma.eNetworkServicePtrVector___delslice__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__delitem__ = new_instancemethod(_enigma.eNetworkServicePtrVector___delitem__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__getitem__ = new_instancemethod(_enigma.eNetworkServicePtrVector___getitem__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.__setitem__ = new_instancemethod(_enigma.eNetworkServicePtrVector___setitem__,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.append = new_instancemethod(_enigma.eNetworkServicePtrVector_append,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.empty = new_instancemethod(_enigma.eNetworkServicePtrVector_empty,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.size = new_instancemethod(_enigma.eNetworkServicePtrVector_size,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.clear = new_instancemethod(_enigma.eNetworkServicePtrVector_clear,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.swap = new_instancemethod(_enigma.eNetworkServicePtrVector_swap,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.get_allocator = new_instancemethod(_enigma.eNetworkServicePtrVector_get_allocator,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.begin = new_instancemethod(_enigma.eNetworkServicePtrVector_begin,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.end = new_instancemethod(_enigma.eNetworkServicePtrVector_end,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.rbegin = new_instancemethod(_enigma.eNetworkServicePtrVector_rbegin,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.rend = new_instancemethod(_enigma.eNetworkServicePtrVector_rend,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.pop_back = new_instancemethod(_enigma.eNetworkServicePtrVector_pop_back,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.erase = new_instancemethod(_enigma.eNetworkServicePtrVector_erase,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.push_back = new_instancemethod(_enigma.eNetworkServicePtrVector_push_back,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.front = new_instancemethod(_enigma.eNetworkServicePtrVector_front,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.back = new_instancemethod(_enigma.eNetworkServicePtrVector_back,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.assign = new_instancemethod(_enigma.eNetworkServicePtrVector_assign,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.resize = new_instancemethod(_enigma.eNetworkServicePtrVector_resize,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.insert = new_instancemethod(_enigma.eNetworkServicePtrVector_insert,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.reserve = new_instancemethod(_enigma.eNetworkServicePtrVector_reserve,None,eNetworkServicePtrVector)
eNetworkServicePtrVector.capacity = new_instancemethod(_enigma.eNetworkServicePtrVector_capacity,None,eNetworkServicePtrVector)
eNetworkServicePtrVector_swigregister = _enigma.eNetworkServicePtrVector_swigregister
eNetworkServicePtrVector_swigregister(eNetworkServicePtrVector)

class eNetworkTechnology(iObject):
    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 name(self):
        """name(eNetworkTechnology self) -> std::string const"""
        return _enigma.eNetworkTechnology_name(self)

    def type(self):
        """type(eNetworkTechnology self) -> std::string const"""
        return _enigma.eNetworkTechnology_type(self)

    def powered(self):
        """powered(eNetworkTechnology self) -> bool"""
        return _enigma.eNetworkTechnology_powered(self)

    def setPowered(self, *args):
        """setPowered(eNetworkTechnology self, bool powered)"""
        return _enigma.eNetworkTechnology_setPowered(self, *args)

    def connected(self):
        """connected(eNetworkTechnology self) -> bool"""
        return _enigma.eNetworkTechnology_connected(self)

    def objPath(self):
        """objPath(eNetworkTechnology self) -> std::string const"""
        return _enigma.eNetworkTechnology_objPath(self)

    def path(self):
        """path(eNetworkTechnology self) -> std::string"""
        return _enigma.eNetworkTechnology_path(self)

    def idleTimeout(self):
        """idleTimeout(eNetworkTechnology self) -> uint32_t"""
        return _enigma.eNetworkTechnology_idleTimeout(self)

    def setIdleTimeout(self, *args):
        """setIdleTimeout(eNetworkTechnology self, quint32 timeout)"""
        return _enigma.eNetworkTechnology_setIdleTimeout(self, *args)

    def tethering(self):
        """tethering(eNetworkTechnology self) -> bool"""
        return _enigma.eNetworkTechnology_tethering(self)

    def setTethering(self, *args):
        """setTethering(eNetworkTechnology self, bool enabled)"""
        return _enigma.eNetworkTechnology_setTethering(self, *args)

    def tetheringId(self):
        """tetheringId(eNetworkTechnology self) -> std::string"""
        return _enigma.eNetworkTechnology_tetheringId(self)

    def setTetheringId(self, *args):
        """setTetheringId(eNetworkTechnology self, std::string const & id)"""
        return _enigma.eNetworkTechnology_setTetheringId(self, *args)

    def tetheringPassphrase(self):
        """tetheringPassphrase(eNetworkTechnology self) -> std::string"""
        return _enigma.eNetworkTechnology_tetheringPassphrase(self)

    def setTetheringPassphrase(self, *args):
        """setTetheringPassphrase(eNetworkTechnology self, std::string const & _pass)"""
        return _enigma.eNetworkTechnology_setTetheringPassphrase(self, *args)

    def scan(self):
        """scan(eNetworkTechnology self)"""
        return _enigma.eNetworkTechnology_scan(self)

    def isScanning(self):
        """isScanning(eNetworkTechnology self) -> bool"""
        return _enigma.eNetworkTechnology_isScanning(self)

    poweredChanged = _swig_property(_enigma.eNetworkTechnology_poweredChanged_get, _enigma.eNetworkTechnology_poweredChanged_set)
    connectedChanged = _swig_property(_enigma.eNetworkTechnology_connectedChanged_get, _enigma.eNetworkTechnology_connectedChanged_set)
    scanFinished = _swig_property(_enigma.eNetworkTechnology_scanFinished_get, _enigma.eNetworkTechnology_scanFinished_set)
    idleTimeoutChanged = _swig_property(_enigma.eNetworkTechnology_idleTimeoutChanged_get, _enigma.eNetworkTechnology_idleTimeoutChanged_set)
    tetheringChanged = _swig_property(_enigma.eNetworkTechnology_tetheringChanged_get, _enigma.eNetworkTechnology_tetheringChanged_set)
    tetheringIdChanged = _swig_property(_enigma.eNetworkTechnology_tetheringIdChanged_get, _enigma.eNetworkTechnology_tetheringIdChanged_set)
    tetheringPassphraseChanged = _swig_property(_enigma.eNetworkTechnology_tetheringPassphraseChanged_get, _enigma.eNetworkTechnology_tetheringPassphraseChanged_set)
eNetworkTechnology.name = new_instancemethod(_enigma.eNetworkTechnology_name,None,eNetworkTechnology)
eNetworkTechnology.type = new_instancemethod(_enigma.eNetworkTechnology_type,None,eNetworkTechnology)
eNetworkTechnology.powered = new_instancemethod(_enigma.eNetworkTechnology_powered,None,eNetworkTechnology)
eNetworkTechnology.setPowered = new_instancemethod(_enigma.eNetworkTechnology_setPowered,None,eNetworkTechnology)
eNetworkTechnology.connected = new_instancemethod(_enigma.eNetworkTechnology_connected,None,eNetworkTechnology)
eNetworkTechnology.objPath = new_instancemethod(_enigma.eNetworkTechnology_objPath,None,eNetworkTechnology)
eNetworkTechnology.path = new_instancemethod(_enigma.eNetworkTechnology_path,None,eNetworkTechnology)
eNetworkTechnology.idleTimeout = new_instancemethod(_enigma.eNetworkTechnology_idleTimeout,None,eNetworkTechnology)
eNetworkTechnology.setIdleTimeout = new_instancemethod(_enigma.eNetworkTechnology_setIdleTimeout,None,eNetworkTechnology)
eNetworkTechnology.tethering = new_instancemethod(_enigma.eNetworkTechnology_tethering,None,eNetworkTechnology)
eNetworkTechnology.setTethering = new_instancemethod(_enigma.eNetworkTechnology_setTethering,None,eNetworkTechnology)
eNetworkTechnology.tetheringId = new_instancemethod(_enigma.eNetworkTechnology_tetheringId,None,eNetworkTechnology)
eNetworkTechnology.setTetheringId = new_instancemethod(_enigma.eNetworkTechnology_setTetheringId,None,eNetworkTechnology)
eNetworkTechnology.tetheringPassphrase = new_instancemethod(_enigma.eNetworkTechnology_tetheringPassphrase,None,eNetworkTechnology)
eNetworkTechnology.setTetheringPassphrase = new_instancemethod(_enigma.eNetworkTechnology_setTetheringPassphrase,None,eNetworkTechnology)
eNetworkTechnology.scan = new_instancemethod(_enigma.eNetworkTechnology_scan,None,eNetworkTechnology)
eNetworkTechnology.isScanning = new_instancemethod(_enigma.eNetworkTechnology_isScanning,None,eNetworkTechnology)
eNetworkTechnology_swigregister = _enigma.eNetworkTechnology_swigregister
eNetworkTechnology_swigregister(eNetworkTechnology)

class eNetworkTechnologyPtr(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): 
        _enigma.eNetworkTechnologyPtr_swiginit(self,_enigma.new_eNetworkTechnologyPtr(*args))
    __swig_destroy__ = _enigma.delete_eNetworkTechnologyPtr
    def name(self):
        """name(eNetworkTechnologyPtr self) -> std::string const"""
        return _enigma.eNetworkTechnologyPtr_name(self)

    def type(self):
        """type(eNetworkTechnologyPtr self) -> std::string const"""
        return _enigma.eNetworkTechnologyPtr_type(self)

    def powered(self):
        """powered(eNetworkTechnologyPtr self) -> bool"""
        return _enigma.eNetworkTechnologyPtr_powered(self)

    def setPowered(self, *args):
        """setPowered(eNetworkTechnologyPtr self, bool powered)"""
        return _enigma.eNetworkTechnologyPtr_setPowered(self, *args)

    def connected(self):
        """connected(eNetworkTechnologyPtr self) -> bool"""
        return _enigma.eNetworkTechnologyPtr_connected(self)

    def objPath(self):
        """objPath(eNetworkTechnologyPtr self) -> std::string const"""
        return _enigma.eNetworkTechnologyPtr_objPath(self)

    def path(self):
        """path(eNetworkTechnologyPtr self) -> std::string"""
        return _enigma.eNetworkTechnologyPtr_path(self)

    def idleTimeout(self):
        """idleTimeout(eNetworkTechnologyPtr self) -> uint32_t"""
        return _enigma.eNetworkTechnologyPtr_idleTimeout(self)

    def setIdleTimeout(self, *args):
        """setIdleTimeout(eNetworkTechnologyPtr self, quint32 timeout)"""
        return _enigma.eNetworkTechnologyPtr_setIdleTimeout(self, *args)

    def tethering(self):
        """tethering(eNetworkTechnologyPtr self) -> bool"""
        return _enigma.eNetworkTechnologyPtr_tethering(self)

    def setTethering(self, *args):
        """setTethering(eNetworkTechnologyPtr self, bool enabled)"""
        return _enigma.eNetworkTechnologyPtr_setTethering(self, *args)

    def tetheringId(self):
        """tetheringId(eNetworkTechnologyPtr self) -> std::string"""
        return _enigma.eNetworkTechnologyPtr_tetheringId(self)

    def setTetheringId(self, *args):
        """setTetheringId(eNetworkTechnologyPtr self, std::string const & id)"""
        return _enigma.eNetworkTechnologyPtr_setTetheringId(self, *args)

    def tetheringPassphrase(self):
        """tetheringPassphrase(eNetworkTechnologyPtr self) -> std::string"""
        return _enigma.eNetworkTechnologyPtr_tetheringPassphrase(self)

    def setTetheringPassphrase(self, *args):
        """setTetheringPassphrase(eNetworkTechnologyPtr self, std::string const & _pass)"""
        return _enigma.eNetworkTechnologyPtr_setTetheringPassphrase(self, *args)

    def scan(self):
        """scan(eNetworkTechnologyPtr self)"""
        return _enigma.eNetworkTechnologyPtr_scan(self)

    def isScanning(self):
        """isScanning(eNetworkTechnologyPtr self) -> bool"""
        return _enigma.eNetworkTechnologyPtr_isScanning(self)

    poweredChanged = _swig_property(_enigma.eNetworkTechnologyPtr_poweredChanged_get, _enigma.eNetworkTechnologyPtr_poweredChanged_set)
    connectedChanged = _swig_property(_enigma.eNetworkTechnologyPtr_connectedChanged_get, _enigma.eNetworkTechnologyPtr_connectedChanged_set)
    scanFinished = _swig_property(_enigma.eNetworkTechnologyPtr_scanFinished_get, _enigma.eNetworkTechnologyPtr_scanFinished_set)
    idleTimeoutChanged = _swig_property(_enigma.eNetworkTechnologyPtr_idleTimeoutChanged_get, _enigma.eNetworkTechnologyPtr_idleTimeoutChanged_set)
    tetheringChanged = _swig_property(_enigma.eNetworkTechnologyPtr_tetheringChanged_get, _enigma.eNetworkTechnologyPtr_tetheringChanged_set)
    tetheringIdChanged = _swig_property(_enigma.eNetworkTechnologyPtr_tetheringIdChanged_get, _enigma.eNetworkTechnologyPtr_tetheringIdChanged_set)
    tetheringPassphraseChanged = _swig_property(_enigma.eNetworkTechnologyPtr_tetheringPassphraseChanged_get, _enigma.eNetworkTechnologyPtr_tetheringPassphraseChanged_set)
eNetworkTechnologyPtr.__ref__ = new_instancemethod(_enigma.eNetworkTechnologyPtr___ref__,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.getPtrString = new_instancemethod(_enigma.eNetworkTechnologyPtr_getPtrString,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.__deref__ = new_instancemethod(_enigma.eNetworkTechnologyPtr___deref__,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.name = new_instancemethod(_enigma.eNetworkTechnologyPtr_name,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.type = new_instancemethod(_enigma.eNetworkTechnologyPtr_type,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.powered = new_instancemethod(_enigma.eNetworkTechnologyPtr_powered,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.setPowered = new_instancemethod(_enigma.eNetworkTechnologyPtr_setPowered,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.connected = new_instancemethod(_enigma.eNetworkTechnologyPtr_connected,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.objPath = new_instancemethod(_enigma.eNetworkTechnologyPtr_objPath,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.path = new_instancemethod(_enigma.eNetworkTechnologyPtr_path,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.idleTimeout = new_instancemethod(_enigma.eNetworkTechnologyPtr_idleTimeout,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.setIdleTimeout = new_instancemethod(_enigma.eNetworkTechnologyPtr_setIdleTimeout,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.tethering = new_instancemethod(_enigma.eNetworkTechnologyPtr_tethering,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.setTethering = new_instancemethod(_enigma.eNetworkTechnologyPtr_setTethering,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.tetheringId = new_instancemethod(_enigma.eNetworkTechnologyPtr_tetheringId,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.setTetheringId = new_instancemethod(_enigma.eNetworkTechnologyPtr_setTetheringId,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.tetheringPassphrase = new_instancemethod(_enigma.eNetworkTechnologyPtr_tetheringPassphrase,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.setTetheringPassphrase = new_instancemethod(_enigma.eNetworkTechnologyPtr_setTetheringPassphrase,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.scan = new_instancemethod(_enigma.eNetworkTechnologyPtr_scan,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr.isScanning = new_instancemethod(_enigma.eNetworkTechnologyPtr_isScanning,None,eNetworkTechnologyPtr)
eNetworkTechnologyPtr_swigregister = _enigma.eNetworkTechnologyPtr_swigregister
eNetworkTechnologyPtr_swigregister(eNetworkTechnologyPtr)

class eNetworkTechnologyPtrVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.eNetworkTechnologyPtrVector_swiginit(self,_enigma.new_eNetworkTechnologyPtrVector(*args))
    __swig_destroy__ = _enigma.delete_eNetworkTechnologyPtrVector
eNetworkTechnologyPtrVector.iterator = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_iterator,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__nonzero__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___nonzero__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__bool__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___bool__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__len__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___len__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.pop = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_pop,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__getslice__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___getslice__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__setslice__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___setslice__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__delslice__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___delslice__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__delitem__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___delitem__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__getitem__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___getitem__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.__setitem__ = new_instancemethod(_enigma.eNetworkTechnologyPtrVector___setitem__,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.append = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_append,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.empty = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_empty,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.size = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_size,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.clear = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_clear,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.swap = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_swap,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.get_allocator = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_get_allocator,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.begin = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_begin,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.end = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_end,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.rbegin = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_rbegin,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.rend = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_rend,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.pop_back = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_pop_back,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.erase = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_erase,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.push_back = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_push_back,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.front = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_front,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.back = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_back,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.assign = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_assign,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.resize = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_resize,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.insert = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_insert,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.reserve = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_reserve,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.capacity = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_capacity,None,eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector_swigregister = _enigma.eNetworkTechnologyPtrVector_swigregister
eNetworkTechnologyPtrVector_swigregister(eNetworkTechnologyPtrVector)

class eAVSwitch(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.eAVSwitch_getInstance)
    vcr_sb_notifier = _swig_property(_enigma.eAVSwitch_vcr_sb_notifier_get, _enigma.eAVSwitch_vcr_sb_notifier_set)
eAVSwitch.haveScartSwitch = new_instancemethod(_enigma.eAVSwitch_haveScartSwitch,None,eAVSwitch)
eAVSwitch.getVCRSlowBlanking = new_instancemethod(_enigma.eAVSwitch_getVCRSlowBlanking,None,eAVSwitch)
eAVSwitch.setColorFormat = new_instancemethod(_enigma.eAVSwitch_setColorFormat,None,eAVSwitch)
eAVSwitch.setAspectRatio = new_instancemethod(_enigma.eAVSwitch_setAspectRatio,None,eAVSwitch)
eAVSwitch.setVideomode = new_instancemethod(_enigma.eAVSwitch_setVideomode,None,eAVSwitch)
eAVSwitch.setInput = new_instancemethod(_enigma.eAVSwitch_setInput,None,eAVSwitch)
eAVSwitch.setWSS = new_instancemethod(_enigma.eAVSwitch_setWSS,None,eAVSwitch)
eAVSwitch_swigregister = _enigma.eAVSwitch_swigregister
eAVSwitch_swigregister(eAVSwitch)

def eAVSwitch_getInstance():
  return _enigma.eAVSwitch_getInstance()
eAVSwitch_getInstance = _enigma.eAVSwitch_getInstance

class eRFmod(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.eRFmod_getInstance)
eRFmod.detected = new_instancemethod(_enigma.eRFmod_detected,None,eRFmod)
eRFmod.setFunction = new_instancemethod(_enigma.eRFmod_setFunction,None,eRFmod)
eRFmod.setTestmode = new_instancemethod(_enigma.eRFmod_setTestmode,None,eRFmod)
eRFmod.setSoundFunction = new_instancemethod(_enigma.eRFmod_setSoundFunction,None,eRFmod)
eRFmod.setSoundCarrier = new_instancemethod(_enigma.eRFmod_setSoundCarrier,None,eRFmod)
eRFmod.setChannel = new_instancemethod(_enigma.eRFmod_setChannel,None,eRFmod)
eRFmod.setFinetune = new_instancemethod(_enigma.eRFmod_setFinetune,None,eRFmod)
eRFmod_swigregister = _enigma.eRFmod_swigregister
eRFmod_swigregister(eRFmod)

def eRFmod_getInstance():
  return _enigma.eRFmod_getInstance()
eRFmod_getInstance = _enigma.eRFmod_getInstance

class Misc_Options(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.Misc_Options_getInstance)
    __swig_destroy__ = _enigma.delete_Misc_Options
Misc_Options.set_12V_output = new_instancemethod(_enigma.Misc_Options_set_12V_output,None,Misc_Options)
Misc_Options.get_12V_output = new_instancemethod(_enigma.Misc_Options_get_12V_output,None,Misc_Options)
Misc_Options.detected_12V_output = new_instancemethod(_enigma.Misc_Options_detected_12V_output,None,Misc_Options)
Misc_Options_swigregister = _enigma.Misc_Options_swigregister
Misc_Options_swigregister(Misc_Options)

def Misc_Options_getInstance():
  return _enigma.Misc_Options_getInstance()
Misc_Options_getInstance = _enigma.Misc_Options_getInstance


def e_tzset():
  return _enigma.e_tzset()
e_tzset = _enigma.e_tzset
LCD_CONTRAST_MIN = _enigma.LCD_CONTRAST_MIN
LCD_CONTRAST_MAX = _enigma.LCD_CONTRAST_MAX
LCD_BRIGHTNESS_MIN = _enigma.LCD_BRIGHTNESS_MIN
LCD_BRIGHTNESS_MAX = _enigma.LCD_BRIGHTNESS_MAX
class eLCD(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")
    __repr__ = _swig_repr
eLCD.lock = new_instancemethod(_enigma.eLCD_lock,None,eLCD)
eLCD.unlock = new_instancemethod(_enigma.eLCD_unlock,None,eLCD)
eLCD.islocked = new_instancemethod(_enigma.eLCD_islocked,None,eLCD)
eLCD.detected = new_instancemethod(_enigma.eLCD_detected,None,eLCD)
eLCD_swigregister = _enigma.eLCD_swigregister
eLCD_swigregister(eLCD)

class eDBoxLCD(eLCD):
    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
    getInstance = staticmethod(_enigma.eDBoxLCD_getInstance)
eDBoxLCD.setLCDContrast = new_instancemethod(_enigma.eDBoxLCD_setLCDContrast,None,eDBoxLCD)
eDBoxLCD.setLCDBrightness = new_instancemethod(_enigma.eDBoxLCD_setLCDBrightness,None,eDBoxLCD)
eDBoxLCD.setInverted = new_instancemethod(_enigma.eDBoxLCD_setInverted,None,eDBoxLCD)
eDBoxLCD.isOled = new_instancemethod(_enigma.eDBoxLCD_isOled,None,eDBoxLCD)
eDBoxLCD.update = new_instancemethod(_enigma.eDBoxLCD_update,None,eDBoxLCD)
eDBoxLCD_swigregister = _enigma.eDBoxLCD_swigregister
eDBoxLCD_swigregister(eDBoxLCD)

def eDBoxLCD_getInstance():
  return _enigma.eDBoxLCD_getInstance()
eDBoxLCD_getInstance = _enigma.eDBoxLCD_getInstance

class eMMI_UI(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
eMMI_UI.getState = new_instancemethod(_enigma.eMMI_UI_getState,None,eMMI_UI)
eMMI_UI.setState = new_instancemethod(_enigma.eMMI_UI_setState,None,eMMI_UI)
eMMI_UI.getAppName = new_instancemethod(_enigma.eMMI_UI_getAppName,None,eMMI_UI)
eMMI_UI.setAppName = new_instancemethod(_enigma.eMMI_UI_setAppName,None,eMMI_UI)
eMMI_UI.availableMMI = new_instancemethod(_enigma.eMMI_UI_availableMMI,None,eMMI_UI)
eMMI_UI.getMMIScreen = new_instancemethod(_enigma.eMMI_UI_getMMIScreen,None,eMMI_UI)
eMMI_UI_swigregister = _enigma.eMMI_UI_swigregister
eMMI_UI_swigregister(eMMI_UI)

class eDVBCIInterfaces(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.eDVBCIInterfaces_getInstance)
eDVBCIInterfaces.getNumOfSlots = new_instancemethod(_enigma.eDVBCIInterfaces_getNumOfSlots,None,eDVBCIInterfaces)
eDVBCIInterfaces.getProviderRules = new_instancemethod(_enigma.eDVBCIInterfaces_getProviderRules,None,eDVBCIInterfaces)
eDVBCIInterfaces.getServiceRules = new_instancemethod(_enigma.eDVBCIInterfaces_getServiceRules,None,eDVBCIInterfaces)
eDVBCIInterfaces.getCaidRules = new_instancemethod(_enigma.eDVBCIInterfaces_getCaidRules,None,eDVBCIInterfaces)
eDVBCIInterfaces.setProviderRules = new_instancemethod(_enigma.eDVBCIInterfaces_setProviderRules,None,eDVBCIInterfaces)
eDVBCIInterfaces.setServiceRules = new_instancemethod(_enigma.eDVBCIInterfaces_setServiceRules,None,eDVBCIInterfaces)
eDVBCIInterfaces.setCaidRules = new_instancemethod(_enigma.eDVBCIInterfaces_setCaidRules,None,eDVBCIInterfaces)
eDVBCIInterfaces.readCICaIds = new_instancemethod(_enigma.eDVBCIInterfaces_readCICaIds,None,eDVBCIInterfaces)
eDVBCIInterfaces.getTunerTsInput = new_instancemethod(_enigma.eDVBCIInterfaces_getTunerTsInput,None,eDVBCIInterfaces)
eDVBCIInterfaces_swigregister = _enigma.eDVBCIInterfaces_swigregister
eDVBCIInterfaces_swigregister(eDVBCIInterfaces)

def eDVBCIInterfaces_getInstance():
  return _enigma.eDVBCIInterfaces_getInstance()
eDVBCIInterfaces_getInstance = _enigma.eDVBCIInterfaces_getInstance

class eDVBCI_UI(eMMI_UI):
    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
    rateNormal = _enigma.eDVBCI_UI_rateNormal
    rateHigh = _enigma.eDVBCI_UI_rateHigh
    ciStateChanged = _swig_property(_enigma.eDVBCI_UI_ciStateChanged_get, _enigma.eDVBCI_UI_ciStateChanged_set)
    getInstance = staticmethod(_enigma.eDVBCI_UI_getInstance)
    __swig_destroy__ = _enigma.delete_eDVBCI_UI
eDVBCI_UI.setInit = new_instancemethod(_enigma.eDVBCI_UI_setInit,None,eDVBCI_UI)
eDVBCI_UI.setReset = new_instancemethod(_enigma.eDVBCI_UI_setReset,None,eDVBCI_UI)
eDVBCI_UI.startMMI = new_instancemethod(_enigma.eDVBCI_UI_startMMI,None,eDVBCI_UI)
eDVBCI_UI.stopMMI = new_instancemethod(_enigma.eDVBCI_UI_stopMMI,None,eDVBCI_UI)
eDVBCI_UI.getMMIState = new_instancemethod(_enigma.eDVBCI_UI_getMMIState,None,eDVBCI_UI)
eDVBCI_UI.answerMenu = new_instancemethod(_enigma.eDVBCI_UI_answerMenu,None,eDVBCI_UI)
eDVBCI_UI.answerEnq = new_instancemethod(_enigma.eDVBCI_UI_answerEnq,None,eDVBCI_UI)
eDVBCI_UI.cancelEnq = new_instancemethod(_enigma.eDVBCI_UI_cancelEnq,None,eDVBCI_UI)
eDVBCI_UI.setClockRate = new_instancemethod(_enigma.eDVBCI_UI_setClockRate,None,eDVBCI_UI)
eDVBCI_UI_swigregister = _enigma.eDVBCI_UI_swigregister
eDVBCI_UI_swigregister(eDVBCI_UI)

def eDVBCI_UI_getInstance():
  return _enigma.eDVBCI_UI_getInstance()
eDVBCI_UI_getInstance = _enigma.eDVBCI_UI_getInstance

class eDVBDB(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")
    __repr__ = _swig_repr
    getInstance = staticmethod(_enigma.eDVBDB_getInstance)
eDVBDB.removeFlags = new_instancemethod(_enigma.eDVBDB_removeFlags,None,eDVBDB)
eDVBDB.removeServices = new_instancemethod(_enigma.eDVBDB_removeServices,None,eDVBDB)
eDVBDB.removeService = new_instancemethod(_enigma.eDVBDB_removeService,None,eDVBDB)
eDVBDB.addFlag = new_instancemethod(_enigma.eDVBDB_addFlag,None,eDVBDB)
eDVBDB.removeFlag = new_instancemethod(_enigma.eDVBDB_removeFlag,None,eDVBDB)
eDVBDB.readSatellites = new_instancemethod(_enigma.eDVBDB_readSatellites,None,eDVBDB)
eDVBDB.readTerrestrials = new_instancemethod(_enigma.eDVBDB_readTerrestrials,None,eDVBDB)
eDVBDB.readCables = new_instancemethod(_enigma.eDVBDB_readCables,None,eDVBDB)
eDVBDB.loadServicelist = new_instancemethod(_enigma.eDVBDB_loadServicelist,None,eDVBDB)
eDVBDB.reloadServicelist = new_instancemethod(_enigma.eDVBDB_reloadServicelist,None,eDVBDB)
eDVBDB.saveServicelist = new_instancemethod(_enigma.eDVBDB_saveServicelist,None,eDVBDB)
eDVBDB.reloadBouquets = new_instancemethod(_enigma.eDVBDB_reloadBouquets,None,eDVBDB)
eDVBDB.parseServiceData = new_instancemethod(_enigma.eDVBDB_parseServiceData,None,eDVBDB)
eDVBDB_swigregister = _enigma.eDVBDB_swigregister
eDVBDB_swigregister(eDVBDB)

def eDVBDB_getInstance():
  return _enigma.eDVBDB_getInstance()
eDVBDB_getInstance = _enigma.eDVBDB_getInstance

class ePicLoad(iObject):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    PictureData = _swig_property(_enigma.ePicLoad_PictureData_get, _enigma.ePicLoad_PictureData_set)
    def __init__(self): 
        _enigma.ePicLoad_swiginit(self,_enigma.new_ePicLoad())
    __swig_destroy__ = _enigma.delete_ePicLoad
ePicLoad.startDecode = new_instancemethod(_enigma.ePicLoad_startDecode,None,ePicLoad)
ePicLoad.getThumbnail = new_instancemethod(_enigma.ePicLoad_getThumbnail,None,ePicLoad)
ePicLoad.setPara = new_instancemethod(_enigma.ePicLoad_setPara,None,ePicLoad)
ePicLoad.getInfo = new_instancemethod(_enigma.ePicLoad_getInfo,None,ePicLoad)
ePicLoad.getData = new_instancemethod(_enigma.ePicLoad_getData,None,ePicLoad)
ePicLoad_swigregister = _enigma.ePicLoad_swigregister
ePicLoad_swigregister(ePicLoad)


def loadPic(*args):
  return _enigma.loadPic(*args)
loadPic = _enigma.loadPic
class eCec(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    MSG_ACTIVE_SOURCE = _enigma.eCec_MSG_ACTIVE_SOURCE
    MSG_IMAGE_VIEW_ON = _enigma.eCec_MSG_IMAGE_VIEW_ON
    MSG_TEXT_VIEW_ON = _enigma.eCec_MSG_TEXT_VIEW_ON
    MSG_INACTIVE_SOURCE = _enigma.eCec_MSG_INACTIVE_SOURCE
    MSG_REQUEST_ACTIVE_SOURCE = _enigma.eCec_MSG_REQUEST_ACTIVE_SOURCE
    MSG_ROUTING_CHANGE = _enigma.eCec_MSG_ROUTING_CHANGE
    MSG_ROUTING_INFORMATION = _enigma.eCec_MSG_ROUTING_INFORMATION
    MSG_SET_STREAMPATH = _enigma.eCec_MSG_SET_STREAMPATH
    MSG_STANDBY = _enigma.eCec_MSG_STANDBY
    MSG_VERSION = _enigma.eCec_MSG_VERSION
    MSG_GET_CEC_VERSION = _enigma.eCec_MSG_GET_CEC_VERSION
    MSG_GIVE_PHYS_ADDR = _enigma.eCec_MSG_GIVE_PHYS_ADDR
    MSG_GET_MENU_LANG = _enigma.eCec_MSG_GET_MENU_LANG
    MSG_REPORT_PHYS_ADDR = _enigma.eCec_MSG_REPORT_PHYS_ADDR
    MSG_SET_MENU_LANG = _enigma.eCec_MSG_SET_MENU_LANG
    MSG_DEVICE_VENDOR_ID = _enigma.eCec_MSG_DEVICE_VENDOR_ID
    MSG_GIVE_DEVICE_VENDOR_ID = _enigma.eCec_MSG_GIVE_DEVICE_VENDOR_ID
    MSG_VENDOR_COMMAND = _enigma.eCec_MSG_VENDOR_COMMAND
    MSG_VENDOR_COMMAND_WITH_ID = _enigma.eCec_MSG_VENDOR_COMMAND_WITH_ID
    MSG_VENDOR_REMOTE_BUTTON_DOWN = _enigma.eCec_MSG_VENDOR_REMOTE_BUTTON_DOWN
    MSG_VENDOR_REMOTE_BUTTON_UP = _enigma.eCec_MSG_VENDOR_REMOTE_BUTTON_UP
    MSG_SET_OSD_STRING = _enigma.eCec_MSG_SET_OSD_STRING
    MSG_GIVE_OSD_NAME = _enigma.eCec_MSG_GIVE_OSD_NAME
    MSG_SET_OSD_NAME = _enigma.eCec_MSG_SET_OSD_NAME
    MSG_MENU_REQUEST = _enigma.eCec_MSG_MENU_REQUEST
    MSG_MENU_STATUS = _enigma.eCec_MSG_MENU_STATUS
    MSG_USER_CONTROL_PRESSED = _enigma.eCec_MSG_USER_CONTROL_PRESSED
    MSG_USER_CONTROL_RELEASED = _enigma.eCec_MSG_USER_CONTROL_RELEASED
    MSG_GIVE_DEVICE_POWER_STATUS = _enigma.eCec_MSG_GIVE_DEVICE_POWER_STATUS
    MSG_REPORT_POWER_STATUS = _enigma.eCec_MSG_REPORT_POWER_STATUS
    MSG_FEATURE_ABORT = _enigma.eCec_MSG_FEATURE_ABORT
    MSG_ABORT_MESSAGE = _enigma.eCec_MSG_ABORT_MESSAGE
    MSG_GIVE_AUDIO_STATUS = _enigma.eCec_MSG_GIVE_AUDIO_STATUS
    MSG_GIVE_SYSTEM_AUDIO_MODE_STATUS = _enigma.eCec_MSG_GIVE_SYSTEM_AUDIO_MODE_STATUS
    MSG_REPORT_AUDIO_STATUS = _enigma.eCec_MSG_REPORT_AUDIO_STATUS
    MSG_SET_SYSTEM_AUDIO_MODE = _enigma.eCec_MSG_SET_SYSTEM_AUDIO_MODE
    MSG_SYSTEM_AUDIO_MODE_REQUEST = _enigma.eCec_MSG_SYSTEM_AUDIO_MODE_REQUEST
    MSG_SYSTEM_AUDIO_MODE_STATUS = _enigma.eCec_MSG_SYSTEM_AUDIO_MODE_STATUS
    MSG_SET_AUDIO_RATE = _enigma.eCec_MSG_SET_AUDIO_RATE
    ADDR_TV = _enigma.eCec_ADDR_TV
    ADDR_RECORDING_DEVICE_1 = _enigma.eCec_ADDR_RECORDING_DEVICE_1
    ADDR_ADDR_RECORDING_DEVICE_2 = _enigma.eCec_ADDR_ADDR_RECORDING_DEVICE_2
    ADDR_TUNER_1 = _enigma.eCec_ADDR_TUNER_1
    ADDR_PLAYBACK_DEVICE_1 = _enigma.eCec_ADDR_PLAYBACK_DEVICE_1
    ADDR_AUDIO_SYSTEM = _enigma.eCec_ADDR_AUDIO_SYSTEM
    ADDR_TUNER_2 = _enigma.eCec_ADDR_TUNER_2
    ADDR_TUNER_3 = _enigma.eCec_ADDR_TUNER_3
    ADDR_PLAYBACK_DEVICE_2 = _enigma.eCec_ADDR_PLAYBACK_DEVICE_2
    ADDR_RECORDING_DEVICE_2 = _enigma.eCec_ADDR_RECORDING_DEVICE_2
    ADDR_TUNER_4 = _enigma.eCec_ADDR_TUNER_4
    ADDR_PLAYBACK_DEVICE_3 = _enigma.eCec_ADDR_PLAYBACK_DEVICE_3
    ADDR_RESERVED_1 = _enigma.eCec_ADDR_RESERVED_1
    ADDR_RESERVED_2 = _enigma.eCec_ADDR_RESERVED_2
    ADDR_FREE_USE = _enigma.eCec_ADDR_FREE_USE
    ADDR_UNREGISTERED_BROADCAST = _enigma.eCec_ADDR_UNREGISTERED_BROADCAST
    VENDOR_DREAM = _enigma.eCec_VENDOR_DREAM
    VENDOR_AKAI = _enigma.eCec_VENDOR_AKAI
    VENDOR_AOC = _enigma.eCec_VENDOR_AOC
    VENDOR_BENQ = _enigma.eCec_VENDOR_BENQ
    VENDOR_BROADCOM = _enigma.eCec_VENDOR_BROADCOM
    VENDOR_DAEWOO = _enigma.eCec_VENDOR_DAEWOO
    VENDOR_DENON = _enigma.eCec_VENDOR_DENON
    VENDOR_GRUNDIG = _enigma.eCec_VENDOR_GRUNDIG
    VENDOR_HARMAN_KARDON = _enigma.eCec_VENDOR_HARMAN_KARDON
    VENDOR_HARMAN_KARDON2 = _enigma.eCec_VENDOR_HARMAN_KARDON2
    VENDOR_LG = _enigma.eCec_VENDOR_LG
    VENDOR_LOEWE = _enigma.eCec_VENDOR_LOEWE
    VENDOR_MARANTZ = _enigma.eCec_VENDOR_MARANTZ
    VENDOR_MEDION = _enigma.eCec_VENDOR_MEDION
    VENDOR_ONKYO = _enigma.eCec_VENDOR_ONKYO
    VENDOR_PANASONIC = _enigma.eCec_VENDOR_PANASONIC
    VENDOR_PHILIPS = _enigma.eCec_VENDOR_PHILIPS
    VENDOR_PIONEER = _enigma.eCec_VENDOR_PIONEER
    VENDOR_PULSE_EIGHT = _enigma.eCec_VENDOR_PULSE_EIGHT
    VENDOR_SAMSUNG = _enigma.eCec_VENDOR_SAMSUNG
    VENDOR_SHARP = _enigma.eCec_VENDOR_SHARP
    VENDOR_SONY = _enigma.eCec_VENDOR_SONY
    VENDOR_TOSHIBA = _enigma.eCec_VENDOR_TOSHIBA
    VENDOR_TOSHIBA2 = _enigma.eCec_VENDOR_TOSHIBA2
    VENDOR_VIZIO = _enigma.eCec_VENDOR_VIZIO
    VENDOR_YAMAHA = _enigma.eCec_VENDOR_YAMAHA
    VENDOR_UNKNOWN = _enigma.eCec_VENDOR_UNKNOWN
    def vendor(*args):
        """vendor(uint32_t id) -> std::string const"""
        return _enigma.eCec_vendor(*args)

    vendor = staticmethod(vendor)
    POWER_STATE_ON = _enigma.eCec_POWER_STATE_ON
    POWER_STATE_STANDBY = _enigma.eCec_POWER_STATE_STANDBY
    POWER_STATE_TRANSITION_STANDBY_TO_ON = _enigma.eCec_POWER_STATE_TRANSITION_STANDBY_TO_ON
    POWER_STATE_TRANSITION_ON_TO_STANDBY = _enigma.eCec_POWER_STATE_TRANSITION_ON_TO_STANDBY
    POWER_STATE_UNKNOWN = _enigma.eCec_POWER_STATE_UNKNOWN
    def __init__(self): 
        """__init__(eCec self) -> eCec"""
        _enigma.eCec_swiginit(self,_enigma.new_eCec())
    __swig_destroy__ = _enigma.delete_eCec
    def getInstance():
        """getInstance() -> eCec"""
        return _enigma.eCec_getInstance()

    getInstance = staticmethod(getInstance)
    def set_powerstate(self, *args):
        """set_powerstate(eCec self, uint8_t newstate)"""
        return _enigma.eCec_set_powerstate(self, *args)

    def cec_otp_source_enable(self):
        """cec_otp_source_enable(eCec self)"""
        return _enigma.eCec_cec_otp_source_enable(self)

    def cec_otp_source_disable(self):
        """cec_otp_source_disable(eCec self)"""
        return _enigma.eCec_cec_otp_source_disable(self)

    def cec_ss_standby(self, *args):
        """cec_ss_standby(eCec self, int dest)"""
        return _enigma.eCec_cec_ss_standby(self, *args)

    def cec_give_system_audio_mode_status(self):
        """cec_give_system_audio_mode_status(eCec self)"""
        return _enigma.eCec_cec_give_system_audio_mode_status(self)

    def cec_system_audio_mode_request(self):
        """cec_system_audio_mode_request(eCec self)"""
        return _enigma.eCec_cec_system_audio_mode_request(self)

    def cec_sendkey(self, *args):
        """
        cec_sendkey(eCec self, int dest, int code, bool release=False)
        cec_sendkey(eCec self, int dest, int code)
        """
        return _enigma.eCec_cec_sendkey(self, *args)

    def cec_register_raw_command(self, *args):
        """cec_register_raw_command(eCec self, unsigned char cmd)"""
        return _enigma.eCec_cec_register_raw_command(self, *args)

    def cec_unregister_raw_command(self, *args):
        """cec_unregister_raw_command(eCec self, unsigned char cmd)"""
        return _enigma.eCec_cec_unregister_raw_command(self, *args)

    def get_volume_control_dest(self):
        """get_volume_control_dest(eCec self) -> int"""
        return _enigma.eCec_get_volume_control_dest(self)

    def setPowerstate(self, *args):
        """setPowerstate(eCec self, uint8_t newstate)"""
        return _enigma.eCec_setPowerstate(self, *args)

    def otpEnable(self):
        """otpEnable(eCec self)"""
        return _enigma.eCec_otpEnable(self)

    def otpDisable(self):
        """otpDisable(eCec self)"""
        return _enigma.eCec_otpDisable(self)

    def systemStandby(self, *args):
        """systemStandby(eCec self, int dest)"""
        return _enigma.eCec_systemStandby(self, *args)

    def giveSystemAudioStatus(self):
        """giveSystemAudioStatus(eCec self)"""
        return _enigma.eCec_giveSystemAudioStatus(self)

    def systemAudioRequest(self):
        """systemAudioRequest(eCec self)"""
        return _enigma.eCec_systemAudioRequest(self)

    def sendKey(self, *args):
        """
        sendKey(eCec self, int dest, int code, bool release=False)
        sendKey(eCec self, int dest, int code)
        """
        return _enigma.eCec_sendKey(self, *args)

    def registerRaw(self, *args):
        """registerRaw(eCec self, unsigned char cmd)"""
        return _enigma.eCec_registerRaw(self, *args)

    def unregisterRaw(self, *args):
        """unregisterRaw(eCec self, unsigned char cmd)"""
        return _enigma.eCec_unregisterRaw(self, *args)

    def getVolumeTarget(self):
        """getVolumeTarget(eCec self) -> int"""
        return _enigma.eCec_getVolumeTarget(self)

    receivedStandby = _swig_property(_enigma.eCec_receivedStandby_get, _enigma.eCec_receivedStandby_set)
    isNowActive = _swig_property(_enigma.eCec_isNowActive_get, _enigma.eCec_isNowActive_set)
    receivedRaw = _swig_property(_enigma.eCec_receivedRaw_get, _enigma.eCec_receivedRaw_set)
    receivedMessage = _swig_property(_enigma.eCec_receivedMessage_get, _enigma.eCec_receivedMessage_set)
eCec.set_powerstate = new_instancemethod(_enigma.eCec_set_powerstate,None,eCec)
eCec.cec_otp_source_enable = new_instancemethod(_enigma.eCec_cec_otp_source_enable,None,eCec)
eCec.cec_otp_source_disable = new_instancemethod(_enigma.eCec_cec_otp_source_disable,None,eCec)
eCec.cec_ss_standby = new_instancemethod(_enigma.eCec_cec_ss_standby,None,eCec)
eCec.cec_give_system_audio_mode_status = new_instancemethod(_enigma.eCec_cec_give_system_audio_mode_status,None,eCec)
eCec.cec_system_audio_mode_request = new_instancemethod(_enigma.eCec_cec_system_audio_mode_request,None,eCec)
eCec.cec_sendkey = new_instancemethod(_enigma.eCec_cec_sendkey,None,eCec)
eCec.cec_register_raw_command = new_instancemethod(_enigma.eCec_cec_register_raw_command,None,eCec)
eCec.cec_unregister_raw_command = new_instancemethod(_enigma.eCec_cec_unregister_raw_command,None,eCec)
eCec.get_volume_control_dest = new_instancemethod(_enigma.eCec_get_volume_control_dest,None,eCec)
eCec.setPowerstate = new_instancemethod(_enigma.eCec_setPowerstate,None,eCec)
eCec.otpEnable = new_instancemethod(_enigma.eCec_otpEnable,None,eCec)
eCec.otpDisable = new_instancemethod(_enigma.eCec_otpDisable,None,eCec)
eCec.systemStandby = new_instancemethod(_enigma.eCec_systemStandby,None,eCec)
eCec.giveSystemAudioStatus = new_instancemethod(_enigma.eCec_giveSystemAudioStatus,None,eCec)
eCec.systemAudioRequest = new_instancemethod(_enigma.eCec_systemAudioRequest,None,eCec)
eCec.sendKey = new_instancemethod(_enigma.eCec_sendKey,None,eCec)
eCec.registerRaw = new_instancemethod(_enigma.eCec_registerRaw,None,eCec)
eCec.unregisterRaw = new_instancemethod(_enigma.eCec_unregisterRaw,None,eCec)
eCec.getVolumeTarget = new_instancemethod(_enigma.eCec_getVolumeTarget,None,eCec)
eCec_swigregister = _enigma.eCec_swigregister
eCec_swigregister(eCec)

def eCec_vendor(*args):
  """eCec_vendor(uint32_t id) -> std::string const"""
  return _enigma.eCec_vendor(*args)

def eCec_getInstance():
  """eCec_getInstance() -> eCec"""
  return _enigma.eCec_getInstance()

class eCecDevice(iObject):
    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): 
        _enigma.eCecDevice_swiginit(self,_enigma.new_eCecDevice(*args))
    __swig_destroy__ = _enigma.delete_eCecDevice
    available = _swig_property(_enigma.eCecDevice_available_get, _enigma.eCecDevice_available_set)
    logical = _swig_property(_enigma.eCecDevice_logical_get, _enigma.eCecDevice_logical_set)
    physical = _swig_property(_enigma.eCecDevice_physical_get, _enigma.eCecDevice_physical_set)
    vendor = _swig_property(_enigma.eCecDevice_vendor_get, _enigma.eCecDevice_vendor_set)
    name = _swig_property(_enigma.eCecDevice_name_get, _enigma.eCecDevice_name_set)
    powerstate = _swig_property(_enigma.eCecDevice_powerstate_get, _enigma.eCecDevice_powerstate_set)
eCecDevice_swigregister = _enigma.eCecDevice_swigregister
eCecDevice_swigregister(eCecDevice)

HBBTV_USER_AGENT = _enigma.HBBTV_USER_AGENT
class eHbbtv(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")
    __repr__ = _swig_repr
    VERSION_MAJOR = _enigma.eHbbtv_VERSION_MAJOR
    VERSION_MINOR = _enigma.eHbbtv_VERSION_MINOR
    VERSION_MICRO = _enigma.eHbbtv_VERSION_MICRO
    EVENT_NOW = _enigma.eHbbtv_EVENT_NOW
    EVENT_NEXT = _enigma.eHbbtv_EVENT_NEXT
    BROADCAST_STATE_UNREALIZED = _enigma.eHbbtv_BROADCAST_STATE_UNREALIZED
    BROADCAST_STATE_CONNECTING = _enigma.eHbbtv_BROADCAST_STATE_CONNECTING
    BROADCAST_STATE_PRESENTING = _enigma.eHbbtv_BROADCAST_STATE_PRESENTING
    CHANNEL_ERROR_NOT_SUPPORTED = _enigma.eHbbtv_CHANNEL_ERROR_NOT_SUPPORTED
    CHANNEL_ERROR_TUNE_FAILED = _enigma.eHbbtv_CHANNEL_ERROR_TUNE_FAILED
    CHANNEL_ERROR_TUNER_FOREIGN_LOCK = _enigma.eHbbtv_CHANNEL_ERROR_TUNER_FOREIGN_LOCK
    CHANNEL_ERROR_PARENTAL_LOCK = _enigma.eHbbtv_CHANNEL_ERROR_PARENTAL_LOCK
    CHANNEL_ERROR_CANNOT_DECRYPT = _enigma.eHbbtv_CHANNEL_ERROR_CANNOT_DECRYPT
    CHANNEL_ERROR_UNKNOWN = _enigma.eHbbtv_CHANNEL_ERROR_UNKNOWN
    CHANNEL_ERROR_SWITCH_INTERRUPTED = _enigma.eHbbtv_CHANNEL_ERROR_SWITCH_INTERRUPTED
    CHANNEL_ERROR_LOCKED_BY_RECORD = _enigma.eHbbtv_CHANNEL_ERROR_LOCKED_BY_RECORD
    CHANNEL_ERROR_RESOLVE_FAILED = _enigma.eHbbtv_CHANNEL_ERROR_RESOLVE_FAILED
    CHANNEL_ERROR_BANDWITH_INSUFFICIENT = _enigma.eHbbtv_CHANNEL_ERROR_BANDWITH_INSUFFICIENT
    CHANNEL_ERROR_CANNOT_ZAP = _enigma.eHbbtv_CHANNEL_ERROR_CANNOT_ZAP
    STREAM_STATE_STOPPED = _enigma.eHbbtv_STREAM_STATE_STOPPED
    STREAM_STATE_PLAYING = _enigma.eHbbtv_STREAM_STATE_PLAYING
    STREAM_STATE_PAUSED = _enigma.eHbbtv_STREAM_STATE_PAUSED
    STREAM_STATE_CONNECTING = _enigma.eHbbtv_STREAM_STATE_CONNECTING
    STREAM_STATE_BUFFERING = _enigma.eHbbtv_STREAM_STATE_BUFFERING
    STREAM_STATE_FINISHED = _enigma.eHbbtv_STREAM_STATE_FINISHED
    STREAM_STATE_ERROR = _enigma.eHbbtv_STREAM_STATE_ERROR
    STREAM_ERROR_NONE = _enigma.eHbbtv_STREAM_ERROR_NONE
    STREAM_ERROR_UNSUPPORTED = _enigma.eHbbtv_STREAM_ERROR_UNSUPPORTED
    STREAM_ERROR_CONNECTING = _enigma.eHbbtv_STREAM_ERROR_CONNECTING
    STREAM_ERROR_UNKNOWN = _enigma.eHbbtv_STREAM_ERROR_UNKNOWN
    getInstance = staticmethod(_enigma.eHbbtv_getInstance)
    playServiceRequest = _swig_property(_enigma.eHbbtv_playServiceRequest_get, _enigma.eHbbtv_playServiceRequest_set)
    playStreamRequest = _swig_property(_enigma.eHbbtv_playStreamRequest_get, _enigma.eHbbtv_playStreamRequest_set)
    pauseStreamRequest = _swig_property(_enigma.eHbbtv_pauseStreamRequest_get, _enigma.eHbbtv_pauseStreamRequest_set)
    seekStreamRequest = _swig_property(_enigma.eHbbtv_seekStreamRequest_get, _enigma.eHbbtv_seekStreamRequest_set)
    stopStreamRequest = _swig_property(_enigma.eHbbtv_stopStreamRequest_get, _enigma.eHbbtv_stopStreamRequest_set)
    nextServiceRequest = _swig_property(_enigma.eHbbtv_nextServiceRequest_get, _enigma.eHbbtv_nextServiceRequest_set)
    prevServiceRequest = _swig_property(_enigma.eHbbtv_prevServiceRequest_get, _enigma.eHbbtv_prevServiceRequest_set)
    setVolumeRequest = _swig_property(_enigma.eHbbtv_setVolumeRequest_get, _enigma.eHbbtv_setVolumeRequest_set)
    setVideoWindowRequest = _swig_property(_enigma.eHbbtv_setVideoWindowRequest_get, _enigma.eHbbtv_setVideoWindowRequest_set)
    unsetVideoWindowRequest = _swig_property(_enigma.eHbbtv_unsetVideoWindowRequest_get, _enigma.eHbbtv_unsetVideoWindowRequest_set)
    aitInvalidated = _swig_property(_enigma.eHbbtv_aitInvalidated_get, _enigma.eHbbtv_aitInvalidated_set)
    redButtonAppplicationReady = _swig_property(_enigma.eHbbtv_redButtonAppplicationReady_get, _enigma.eHbbtv_redButtonAppplicationReady_set)
    textApplicationReady = _swig_property(_enigma.eHbbtv_textApplicationReady_get, _enigma.eHbbtv_textApplicationReady_set)
    createApplicationRequest = _swig_property(_enigma.eHbbtv_createApplicationRequest_get, _enigma.eHbbtv_createApplicationRequest_set)
    show = _swig_property(_enigma.eHbbtv_show_get, _enigma.eHbbtv_show_set)
    hide = _swig_property(_enigma.eHbbtv_hide_get, _enigma.eHbbtv_hide_set)
eHbbtv.setAitSignalsEnabled = new_instancemethod(_enigma.eHbbtv_setAitSignalsEnabled,None,eHbbtv)
eHbbtv.setServiceList = new_instancemethod(_enigma.eHbbtv_setServiceList,None,eHbbtv)
eHbbtv.setStreamState = new_instancemethod(_enigma.eHbbtv_setStreamState,None,eHbbtv)
eHbbtv.getApplication = new_instancemethod(_enigma.eHbbtv_getApplication,None,eHbbtv)
eHbbtv.resolveApplicationLocator = new_instancemethod(_enigma.eHbbtv_resolveApplicationLocator,None,eHbbtv)
eHbbtv.getApplicationIdsAndName = new_instancemethod(_enigma.eHbbtv_getApplicationIdsAndName,None,eHbbtv)
eHbbtv.pageLoadFinished = new_instancemethod(_enigma.eHbbtv_pageLoadFinished,None,eHbbtv)
eHbbtv_swigregister = _enigma.eHbbtv_swigregister
eHbbtv_swigregister(eHbbtv)

def eHbbtv_getInstance():
  return _enigma.eHbbtv_getInstance()
eHbbtv_getInstance = _enigma.eHbbtv_getInstance

class eOipfApplication(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")
    __repr__ = _swig_repr
    CONTROL_CODE_AUTOSTART = _enigma.eOipfApplication_CONTROL_CODE_AUTOSTART
    CONTROL_CODE_PRESENT = _enigma.eOipfApplication_CONTROL_CODE_PRESENT
    CONTROL_CODE_DESTROY = _enigma.eOipfApplication_CONTROL_CODE_DESTROY
    CONTROL_CODE_KILL = _enigma.eOipfApplication_CONTROL_CODE_KILL
    CONTROL_CODE_PREFETCH = _enigma.eOipfApplication_CONTROL_CODE_PREFETCH
    CONTROL_CODE_REMOTE = _enigma.eOipfApplication_CONTROL_CODE_REMOTE
    CONTROL_CODE_DISABLED = _enigma.eOipfApplication_CONTROL_CODE_DISABLED
    CONTROL_CODE_PLAYBACK_AUTOSTART = _enigma.eOipfApplication_CONTROL_CODE_PLAYBACK_AUTOSTART
    USAGE_TYPE_TEXT = _enigma.eOipfApplication_USAGE_TYPE_TEXT
    VISIBILITY_NOT_VISIBLE_ALL = _enigma.eOipfApplication_VISIBILITY_NOT_VISIBLE_ALL
    VISIBILITY_NOT_VISIBLE_USERS = _enigma.eOipfApplication_VISIBILITY_NOT_VISIBLE_USERS
    VISIBILITY_VISIBLE_ALL = _enigma.eOipfApplication_VISIBILITY_VISIBLE_ALL
    __swig_destroy__ = _enigma.delete_eOipfApplication
    getById = staticmethod(_enigma.eOipfApplication_getById)
eOipfApplication.isValid = new_instancemethod(_enigma.eOipfApplication_isValid,None,eOipfApplication)
eOipfApplication.getOrganisationId = new_instancemethod(_enigma.eOipfApplication_getOrganisationId,None,eOipfApplication)
eOipfApplication.getApplicationId = new_instancemethod(_enigma.eOipfApplication_getApplicationId,None,eOipfApplication)
eOipfApplication.getApplicationProfile = new_instancemethod(_enigma.eOipfApplication_getApplicationProfile,None,eOipfApplication)
eOipfApplication.getPriority = new_instancemethod(_enigma.eOipfApplication_getPriority,None,eOipfApplication)
eOipfApplication.getUsageType = new_instancemethod(_enigma.eOipfApplication_getUsageType,None,eOipfApplication)
eOipfApplication.getControlCode = new_instancemethod(_enigma.eOipfApplication_getControlCode,None,eOipfApplication)
eOipfApplication.getServiceBoundFlag = new_instancemethod(_enigma.eOipfApplication_getServiceBoundFlag,None,eOipfApplication)
eOipfApplication.getVisibility = new_instancemethod(_enigma.eOipfApplication_getVisibility,None,eOipfApplication)
eOipfApplication.getId = new_instancemethod(_enigma.eOipfApplication_getId,None,eOipfApplication)
eOipfApplication.getName = new_instancemethod(_enigma.eOipfApplication_getName,None,eOipfApplication)
eOipfApplication.getInitialPath = new_instancemethod(_enigma.eOipfApplication_getInitialPath,None,eOipfApplication)
eOipfApplication.getUrlBase = new_instancemethod(_enigma.eOipfApplication_getUrlBase,None,eOipfApplication)
eOipfApplication_swigregister = _enigma.eOipfApplication_swigregister
eOipfApplication_swigregister(eOipfApplication)

def eOipfApplication_getById(*args):
  return _enigma.eOipfApplication_getById(*args)
eOipfApplication_getById = _enigma.eOipfApplication_getById

class PseudoDict(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.PseudoDict_swiginit(self,_enigma.new_PseudoDict(*args))
    def get(self, key, default=None):
        if self.has_key(key):
            return self[key]
        return default
    __swig_destroy__ = _enigma.delete_PseudoDict
PseudoDict.iterator = new_instancemethod(_enigma.PseudoDict_iterator,None,PseudoDict)
PseudoDict.__nonzero__ = new_instancemethod(_enigma.PseudoDict___nonzero__,None,PseudoDict)
PseudoDict.__bool__ = new_instancemethod(_enigma.PseudoDict___bool__,None,PseudoDict)
PseudoDict.__len__ = new_instancemethod(_enigma.PseudoDict___len__,None,PseudoDict)
PseudoDict.__getitem__ = new_instancemethod(_enigma.PseudoDict___getitem__,None,PseudoDict)
PseudoDict.__delitem__ = new_instancemethod(_enigma.PseudoDict___delitem__,None,PseudoDict)
PseudoDict.has_key = new_instancemethod(_enigma.PseudoDict_has_key,None,PseudoDict)
PseudoDict.keys = new_instancemethod(_enigma.PseudoDict_keys,None,PseudoDict)
PseudoDict.values = new_instancemethod(_enigma.PseudoDict_values,None,PseudoDict)
PseudoDict.items = new_instancemethod(_enigma.PseudoDict_items,None,PseudoDict)
PseudoDict.__contains__ = new_instancemethod(_enigma.PseudoDict___contains__,None,PseudoDict)
PseudoDict.key_iterator = new_instancemethod(_enigma.PseudoDict_key_iterator,None,PseudoDict)
PseudoDict.value_iterator = new_instancemethod(_enigma.PseudoDict_value_iterator,None,PseudoDict)
PseudoDict.__setitem__ = new_instancemethod(_enigma.PseudoDict___setitem__,None,PseudoDict)
PseudoDict.asdict = new_instancemethod(_enigma.PseudoDict_asdict,None,PseudoDict)
PseudoDict.empty = new_instancemethod(_enigma.PseudoDict_empty,None,PseudoDict)
PseudoDict.size = new_instancemethod(_enigma.PseudoDict_size,None,PseudoDict)
PseudoDict.clear = new_instancemethod(_enigma.PseudoDict_clear,None,PseudoDict)
PseudoDict.swap = new_instancemethod(_enigma.PseudoDict_swap,None,PseudoDict)
PseudoDict.get_allocator = new_instancemethod(_enigma.PseudoDict_get_allocator,None,PseudoDict)
PseudoDict.begin = new_instancemethod(_enigma.PseudoDict_begin,None,PseudoDict)
PseudoDict.end = new_instancemethod(_enigma.PseudoDict_end,None,PseudoDict)
PseudoDict.rbegin = new_instancemethod(_enigma.PseudoDict_rbegin,None,PseudoDict)
PseudoDict.rend = new_instancemethod(_enigma.PseudoDict_rend,None,PseudoDict)
PseudoDict.count = new_instancemethod(_enigma.PseudoDict_count,None,PseudoDict)
PseudoDict.erase = new_instancemethod(_enigma.PseudoDict_erase,None,PseudoDict)
PseudoDict.find = new_instancemethod(_enigma.PseudoDict_find,None,PseudoDict)
PseudoDict.lower_bound = new_instancemethod(_enigma.PseudoDict_lower_bound,None,PseudoDict)
PseudoDict.upper_bound = new_instancemethod(_enigma.PseudoDict_upper_bound,None,PseudoDict)
PseudoDict_swigregister = _enigma.PseudoDict_swigregister
PseudoDict_swigregister(PseudoDict)

class StringList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.StringList_swiginit(self,_enigma.new_StringList(*args))
    __swig_destroy__ = _enigma.delete_StringList
StringList.iterator = new_instancemethod(_enigma.StringList_iterator,None,StringList)
StringList.__nonzero__ = new_instancemethod(_enigma.StringList___nonzero__,None,StringList)
StringList.__bool__ = new_instancemethod(_enigma.StringList___bool__,None,StringList)
StringList.__len__ = new_instancemethod(_enigma.StringList___len__,None,StringList)
StringList.pop = new_instancemethod(_enigma.StringList_pop,None,StringList)
StringList.__getslice__ = new_instancemethod(_enigma.StringList___getslice__,None,StringList)
StringList.__setslice__ = new_instancemethod(_enigma.StringList___setslice__,None,StringList)
StringList.__delslice__ = new_instancemethod(_enigma.StringList___delslice__,None,StringList)
StringList.__delitem__ = new_instancemethod(_enigma.StringList___delitem__,None,StringList)
StringList.__getitem__ = new_instancemethod(_enigma.StringList___getitem__,None,StringList)
StringList.__setitem__ = new_instancemethod(_enigma.StringList___setitem__,None,StringList)
StringList.append = new_instancemethod(_enigma.StringList_append,None,StringList)
StringList.empty = new_instancemethod(_enigma.StringList_empty,None,StringList)
StringList.size = new_instancemethod(_enigma.StringList_size,None,StringList)
StringList.clear = new_instancemethod(_enigma.StringList_clear,None,StringList)
StringList.swap = new_instancemethod(_enigma.StringList_swap,None,StringList)
StringList.get_allocator = new_instancemethod(_enigma.StringList_get_allocator,None,StringList)
StringList.begin = new_instancemethod(_enigma.StringList_begin,None,StringList)
StringList.end = new_instancemethod(_enigma.StringList_end,None,StringList)
StringList.rbegin = new_instancemethod(_enigma.StringList_rbegin,None,StringList)
StringList.rend = new_instancemethod(_enigma.StringList_rend,None,StringList)
StringList.pop_back = new_instancemethod(_enigma.StringList_pop_back,None,StringList)
StringList.erase = new_instancemethod(_enigma.StringList_erase,None,StringList)
StringList.push_back = new_instancemethod(_enigma.StringList_push_back,None,StringList)
StringList.front = new_instancemethod(_enigma.StringList_front,None,StringList)
StringList.back = new_instancemethod(_enigma.StringList_back,None,StringList)
StringList.assign = new_instancemethod(_enigma.StringList_assign,None,StringList)
StringList.resize = new_instancemethod(_enigma.StringList_resize,None,StringList)
StringList.insert = new_instancemethod(_enigma.StringList_insert,None,StringList)
StringList.pop_front = new_instancemethod(_enigma.StringList_pop_front,None,StringList)
StringList.push_front = new_instancemethod(_enigma.StringList_push_front,None,StringList)
StringList.reverse = new_instancemethod(_enigma.StringList_reverse,None,StringList)
StringList_swigregister = _enigma.StringList_swigregister
StringList_swigregister(StringList)

class StringSet(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.StringSet_swiginit(self,_enigma.new_StringSet(*args))
    __swig_destroy__ = _enigma.delete_StringSet
StringSet.iterator = new_instancemethod(_enigma.StringSet_iterator,None,StringSet)
StringSet.__nonzero__ = new_instancemethod(_enigma.StringSet___nonzero__,None,StringSet)
StringSet.__bool__ = new_instancemethod(_enigma.StringSet___bool__,None,StringSet)
StringSet.__len__ = new_instancemethod(_enigma.StringSet___len__,None,StringSet)
StringSet.append = new_instancemethod(_enigma.StringSet_append,None,StringSet)
StringSet.__contains__ = new_instancemethod(_enigma.StringSet___contains__,None,StringSet)
StringSet.__getitem__ = new_instancemethod(_enigma.StringSet___getitem__,None,StringSet)
StringSet.add = new_instancemethod(_enigma.StringSet_add,None,StringSet)
StringSet.discard = new_instancemethod(_enigma.StringSet_discard,None,StringSet)
StringSet.empty = new_instancemethod(_enigma.StringSet_empty,None,StringSet)
StringSet.size = new_instancemethod(_enigma.StringSet_size,None,StringSet)
StringSet.clear = new_instancemethod(_enigma.StringSet_clear,None,StringSet)
StringSet.swap = new_instancemethod(_enigma.StringSet_swap,None,StringSet)
StringSet.count = new_instancemethod(_enigma.StringSet_count,None,StringSet)
StringSet.begin = new_instancemethod(_enigma.StringSet_begin,None,StringSet)
StringSet.end = new_instancemethod(_enigma.StringSet_end,None,StringSet)
StringSet.rbegin = new_instancemethod(_enigma.StringSet_rbegin,None,StringSet)
StringSet.rend = new_instancemethod(_enigma.StringSet_rend,None,StringSet)
StringSet.erase = new_instancemethod(_enigma.StringSet_erase,None,StringSet)
StringSet.find = new_instancemethod(_enigma.StringSet_find,None,StringSet)
StringSet.lower_bound = new_instancemethod(_enigma.StringSet_lower_bound,None,StringSet)
StringSet.upper_bound = new_instancemethod(_enigma.StringSet_upper_bound,None,StringSet)
StringSet.equal_range = new_instancemethod(_enigma.StringSet_equal_range,None,StringSet)
StringSet.insert = new_instancemethod(_enigma.StringSet_insert,None,StringSet)
StringSet_swigregister = _enigma.StringSet_swigregister
StringSet_swigregister(StringSet)

class StringMap(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.StringMap_swiginit(self,_enigma.new_StringMap(*args))
    def get(self, key, default=None):
        if self.has_key(key):
            return self[key]
        return default
    __swig_destroy__ = _enigma.delete_StringMap
StringMap.iterator = new_instancemethod(_enigma.StringMap_iterator,None,StringMap)
StringMap.__nonzero__ = new_instancemethod(_enigma.StringMap___nonzero__,None,StringMap)
StringMap.__bool__ = new_instancemethod(_enigma.StringMap___bool__,None,StringMap)
StringMap.__len__ = new_instancemethod(_enigma.StringMap___len__,None,StringMap)
StringMap.__getitem__ = new_instancemethod(_enigma.StringMap___getitem__,None,StringMap)
StringMap.__delitem__ = new_instancemethod(_enigma.StringMap___delitem__,None,StringMap)
StringMap.has_key = new_instancemethod(_enigma.StringMap_has_key,None,StringMap)
StringMap.keys = new_instancemethod(_enigma.StringMap_keys,None,StringMap)
StringMap.values = new_instancemethod(_enigma.StringMap_values,None,StringMap)
StringMap.items = new_instancemethod(_enigma.StringMap_items,None,StringMap)
StringMap.__contains__ = new_instancemethod(_enigma.StringMap___contains__,None,StringMap)
StringMap.key_iterator = new_instancemethod(_enigma.StringMap_key_iterator,None,StringMap)
StringMap.value_iterator = new_instancemethod(_enigma.StringMap_value_iterator,None,StringMap)
StringMap.__setitem__ = new_instancemethod(_enigma.StringMap___setitem__,None,StringMap)
StringMap.asdict = new_instancemethod(_enigma.StringMap_asdict,None,StringMap)
StringMap.empty = new_instancemethod(_enigma.StringMap_empty,None,StringMap)
StringMap.size = new_instancemethod(_enigma.StringMap_size,None,StringMap)
StringMap.clear = new_instancemethod(_enigma.StringMap_clear,None,StringMap)
StringMap.swap = new_instancemethod(_enigma.StringMap_swap,None,StringMap)
StringMap.get_allocator = new_instancemethod(_enigma.StringMap_get_allocator,None,StringMap)
StringMap.begin = new_instancemethod(_enigma.StringMap_begin,None,StringMap)
StringMap.end = new_instancemethod(_enigma.StringMap_end,None,StringMap)
StringMap.rbegin = new_instancemethod(_enigma.StringMap_rbegin,None,StringMap)
StringMap.rend = new_instancemethod(_enigma.StringMap_rend,None,StringMap)
StringMap.count = new_instancemethod(_enigma.StringMap_count,None,StringMap)
StringMap.erase = new_instancemethod(_enigma.StringMap_erase,None,StringMap)
StringMap.find = new_instancemethod(_enigma.StringMap_find,None,StringMap)
StringMap.lower_bound = new_instancemethod(_enigma.StringMap_lower_bound,None,StringMap)
StringMap.upper_bound = new_instancemethod(_enigma.StringMap_upper_bound,None,StringMap)
StringMap_swigregister = _enigma.StringMap_swigregister
StringMap_swigregister(StringMap)

class StringMapVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.StringMapVector_swiginit(self,_enigma.new_StringMapVector(*args))
    __swig_destroy__ = _enigma.delete_StringMapVector
StringMapVector.iterator = new_instancemethod(_enigma.StringMapVector_iterator,None,StringMapVector)
StringMapVector.__nonzero__ = new_instancemethod(_enigma.StringMapVector___nonzero__,None,StringMapVector)
StringMapVector.__bool__ = new_instancemethod(_enigma.StringMapVector___bool__,None,StringMapVector)
StringMapVector.__len__ = new_instancemethod(_enigma.StringMapVector___len__,None,StringMapVector)
StringMapVector.pop = new_instancemethod(_enigma.StringMapVector_pop,None,StringMapVector)
StringMapVector.__getslice__ = new_instancemethod(_enigma.StringMapVector___getslice__,None,StringMapVector)
StringMapVector.__setslice__ = new_instancemethod(_enigma.StringMapVector___setslice__,None,StringMapVector)
StringMapVector.__delslice__ = new_instancemethod(_enigma.StringMapVector___delslice__,None,StringMapVector)
StringMapVector.__delitem__ = new_instancemethod(_enigma.StringMapVector___delitem__,None,StringMapVector)
StringMapVector.__getitem__ = new_instancemethod(_enigma.StringMapVector___getitem__,None,StringMapVector)
StringMapVector.__setitem__ = new_instancemethod(_enigma.StringMapVector___setitem__,None,StringMapVector)
StringMapVector.append = new_instancemethod(_enigma.StringMapVector_append,None,StringMapVector)
StringMapVector.empty = new_instancemethod(_enigma.StringMapVector_empty,None,StringMapVector)
StringMapVector.size = new_instancemethod(_enigma.StringMapVector_size,None,StringMapVector)
StringMapVector.clear = new_instancemethod(_enigma.StringMapVector_clear,None,StringMapVector)
StringMapVector.swap = new_instancemethod(_enigma.StringMapVector_swap,None,StringMapVector)
StringMapVector.get_allocator = new_instancemethod(_enigma.StringMapVector_get_allocator,None,StringMapVector)
StringMapVector.begin = new_instancemethod(_enigma.StringMapVector_begin,None,StringMapVector)
StringMapVector.end = new_instancemethod(_enigma.StringMapVector_end,None,StringMapVector)
StringMapVector.rbegin = new_instancemethod(_enigma.StringMapVector_rbegin,None,StringMapVector)
StringMapVector.rend = new_instancemethod(_enigma.StringMapVector_rend,None,StringMapVector)
StringMapVector.pop_back = new_instancemethod(_enigma.StringMapVector_pop_back,None,StringMapVector)
StringMapVector.erase = new_instancemethod(_enigma.StringMapVector_erase,None,StringMapVector)
StringMapVector.push_back = new_instancemethod(_enigma.StringMapVector_push_back,None,StringMapVector)
StringMapVector.front = new_instancemethod(_enigma.StringMapVector_front,None,StringMapVector)
StringMapVector.back = new_instancemethod(_enigma.StringMapVector_back,None,StringMapVector)
StringMapVector.assign = new_instancemethod(_enigma.StringMapVector_assign,None,StringMapVector)
StringMapVector.resize = new_instancemethod(_enigma.StringMapVector_resize,None,StringMapVector)
StringMapVector.insert = new_instancemethod(_enigma.StringMapVector_insert,None,StringMapVector)
StringMapVector.reserve = new_instancemethod(_enigma.StringMapVector_reserve,None,StringMapVector)
StringMapVector.capacity = new_instancemethod(_enigma.StringMapVector_capacity,None,StringMapVector)
StringMapVector_swigregister = _enigma.StringMapVector_swigregister
StringMapVector_swigregister(StringMapVector)

class StringVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.StringVector_swiginit(self,_enigma.new_StringVector(*args))
    __swig_destroy__ = _enigma.delete_StringVector
StringVector.iterator = new_instancemethod(_enigma.StringVector_iterator,None,StringVector)
StringVector.__nonzero__ = new_instancemethod(_enigma.StringVector___nonzero__,None,StringVector)
StringVector.__bool__ = new_instancemethod(_enigma.StringVector___bool__,None,StringVector)
StringVector.__len__ = new_instancemethod(_enigma.StringVector___len__,None,StringVector)
StringVector.pop = new_instancemethod(_enigma.StringVector_pop,None,StringVector)
StringVector.__getslice__ = new_instancemethod(_enigma.StringVector___getslice__,None,StringVector)
StringVector.__setslice__ = new_instancemethod(_enigma.StringVector___setslice__,None,StringVector)
StringVector.__delslice__ = new_instancemethod(_enigma.StringVector___delslice__,None,StringVector)
StringVector.__delitem__ = new_instancemethod(_enigma.StringVector___delitem__,None,StringVector)
StringVector.__getitem__ = new_instancemethod(_enigma.StringVector___getitem__,None,StringVector)
StringVector.__setitem__ = new_instancemethod(_enigma.StringVector___setitem__,None,StringVector)
StringVector.append = new_instancemethod(_enigma.StringVector_append,None,StringVector)
StringVector.empty = new_instancemethod(_enigma.StringVector_empty,None,StringVector)
StringVector.size = new_instancemethod(_enigma.StringVector_size,None,StringVector)
StringVector.clear = new_instancemethod(_enigma.StringVector_clear,None,StringVector)
StringVector.swap = new_instancemethod(_enigma.StringVector_swap,None,StringVector)
StringVector.get_allocator = new_instancemethod(_enigma.StringVector_get_allocator,None,StringVector)
StringVector.begin = new_instancemethod(_enigma.StringVector_begin,None,StringVector)
StringVector.end = new_instancemethod(_enigma.StringVector_end,None,StringVector)
StringVector.rbegin = new_instancemethod(_enigma.StringVector_rbegin,None,StringVector)
StringVector.rend = new_instancemethod(_enigma.StringVector_rend,None,StringVector)
StringVector.pop_back = new_instancemethod(_enigma.StringVector_pop_back,None,StringVector)
StringVector.erase = new_instancemethod(_enigma.StringVector_erase,None,StringVector)
StringVector.push_back = new_instancemethod(_enigma.StringVector_push_back,None,StringVector)
StringVector.front = new_instancemethod(_enigma.StringVector_front,None,StringVector)
StringVector.back = new_instancemethod(_enigma.StringVector_back,None,StringVector)
StringVector.assign = new_instancemethod(_enigma.StringVector_assign,None,StringVector)
StringVector.resize = new_instancemethod(_enigma.StringVector_resize,None,StringVector)
StringVector.insert = new_instancemethod(_enigma.StringVector_insert,None,StringVector)
StringVector.reserve = new_instancemethod(_enigma.StringVector_reserve,None,StringVector)
StringVector.capacity = new_instancemethod(_enigma.StringVector_capacity,None,StringVector)
StringVector_swigregister = _enigma.StringVector_swigregister
StringVector_swigregister(StringVector)

class IntList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.IntList_swiginit(self,_enigma.new_IntList(*args))
    __swig_destroy__ = _enigma.delete_IntList
IntList.iterator = new_instancemethod(_enigma.IntList_iterator,None,IntList)
IntList.__nonzero__ = new_instancemethod(_enigma.IntList___nonzero__,None,IntList)
IntList.__bool__ = new_instancemethod(_enigma.IntList___bool__,None,IntList)
IntList.__len__ = new_instancemethod(_enigma.IntList___len__,None,IntList)
IntList.pop = new_instancemethod(_enigma.IntList_pop,None,IntList)
IntList.__getslice__ = new_instancemethod(_enigma.IntList___getslice__,None,IntList)
IntList.__setslice__ = new_instancemethod(_enigma.IntList___setslice__,None,IntList)
IntList.__delslice__ = new_instancemethod(_enigma.IntList___delslice__,None,IntList)
IntList.__delitem__ = new_instancemethod(_enigma.IntList___delitem__,None,IntList)
IntList.__getitem__ = new_instancemethod(_enigma.IntList___getitem__,None,IntList)
IntList.__setitem__ = new_instancemethod(_enigma.IntList___setitem__,None,IntList)
IntList.append = new_instancemethod(_enigma.IntList_append,None,IntList)
IntList.empty = new_instancemethod(_enigma.IntList_empty,None,IntList)
IntList.size = new_instancemethod(_enigma.IntList_size,None,IntList)
IntList.clear = new_instancemethod(_enigma.IntList_clear,None,IntList)
IntList.swap = new_instancemethod(_enigma.IntList_swap,None,IntList)
IntList.get_allocator = new_instancemethod(_enigma.IntList_get_allocator,None,IntList)
IntList.begin = new_instancemethod(_enigma.IntList_begin,None,IntList)
IntList.end = new_instancemethod(_enigma.IntList_end,None,IntList)
IntList.rbegin = new_instancemethod(_enigma.IntList_rbegin,None,IntList)
IntList.rend = new_instancemethod(_enigma.IntList_rend,None,IntList)
IntList.pop_back = new_instancemethod(_enigma.IntList_pop_back,None,IntList)
IntList.erase = new_instancemethod(_enigma.IntList_erase,None,IntList)
IntList.push_back = new_instancemethod(_enigma.IntList_push_back,None,IntList)
IntList.front = new_instancemethod(_enigma.IntList_front,None,IntList)
IntList.back = new_instancemethod(_enigma.IntList_back,None,IntList)
IntList.assign = new_instancemethod(_enigma.IntList_assign,None,IntList)
IntList.resize = new_instancemethod(_enigma.IntList_resize,None,IntList)
IntList.insert = new_instancemethod(_enigma.IntList_insert,None,IntList)
IntList.pop_front = new_instancemethod(_enigma.IntList_pop_front,None,IntList)
IntList.push_front = new_instancemethod(_enigma.IntList_push_front,None,IntList)
IntList.reverse = new_instancemethod(_enigma.IntList_reverse,None,IntList)
IntList_swigregister = _enigma.IntList_swigregister
IntList_swigregister(IntList)

class WindowAnimationSetMap(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __iter__(self): return self.iterator()
    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __init__(self, *args): 
        _enigma.WindowAnimationSetMap_swiginit(self,_enigma.new_WindowAnimationSetMap(*args))
    __swig_destroy__ = _enigma.delete_WindowAnimationSetMap
WindowAnimationSetMap.iterator = new_instancemethod(_enigma.WindowAnimationSetMap_iterator,None,WindowAnimationSetMap)
WindowAnimationSetMap.__nonzero__ = new_instancemethod(_enigma.WindowAnimationSetMap___nonzero__,None,WindowAnimationSetMap)
WindowAnimationSetMap.__bool__ = new_instancemethod(_enigma.WindowAnimationSetMap___bool__,None,WindowAnimationSetMap)
WindowAnimationSetMap.__len__ = new_instancemethod(_enigma.WindowAnimationSetMap___len__,None,WindowAnimationSetMap)
WindowAnimationSetMap.__getitem__ = new_instancemethod(_enigma.WindowAnimationSetMap___getitem__,None,WindowAnimationSetMap)
WindowAnimationSetMap.__delitem__ = new_instancemethod(_enigma.WindowAnimationSetMap___delitem__,None,WindowAnimationSetMap)
WindowAnimationSetMap.has_key = new_instancemethod(_enigma.WindowAnimationSetMap_has_key,None,WindowAnimationSetMap)
WindowAnimationSetMap.keys = new_instancemethod(_enigma.WindowAnimationSetMap_keys,None,WindowAnimationSetMap)
WindowAnimationSetMap.values = new_instancemethod(_enigma.WindowAnimationSetMap_values,None,WindowAnimationSetMap)
WindowAnimationSetMap.items = new_instancemethod(_enigma.WindowAnimationSetMap_items,None,WindowAnimationSetMap)
WindowAnimationSetMap.__contains__ = new_instancemethod(_enigma.WindowAnimationSetMap___contains__,None,WindowAnimationSetMap)
WindowAnimationSetMap.key_iterator = new_instancemethod(_enigma.WindowAnimationSetMap_key_iterator,None,WindowAnimationSetMap)
WindowAnimationSetMap.value_iterator = new_instancemethod(_enigma.WindowAnimationSetMap_value_iterator,None,WindowAnimationSetMap)
WindowAnimationSetMap.__setitem__ = new_instancemethod(_enigma.WindowAnimationSetMap___setitem__,None,WindowAnimationSetMap)
WindowAnimationSetMap.asdict = new_instancemethod(_enigma.WindowAnimationSetMap_asdict,None,WindowAnimationSetMap)
WindowAnimationSetMap.empty = new_instancemethod(_enigma.WindowAnimationSetMap_empty,None,WindowAnimationSetMap)
WindowAnimationSetMap.size = new_instancemethod(_enigma.WindowAnimationSetMap_size,None,WindowAnimationSetMap)
WindowAnimationSetMap.clear = new_instancemethod(_enigma.WindowAnimationSetMap_clear,None,WindowAnimationSetMap)
WindowAnimationSetMap.swap = new_instancemethod(_enigma.WindowAnimationSetMap_swap,None,WindowAnimationSetMap)
WindowAnimationSetMap.get_allocator = new_instancemethod(_enigma.WindowAnimationSetMap_get_allocator,None,WindowAnimationSetMap)
WindowAnimationSetMap.begin = new_instancemethod(_enigma.WindowAnimationSetMap_begin,None,WindowAnimationSetMap)
WindowAnimationSetMap.end = new_instancemethod(_enigma.WindowAnimationSetMap_end,None,WindowAnimationSetMap)
WindowAnimationSetMap.rbegin = new_instancemethod(_enigma.WindowAnimationSetMap_rbegin,None,WindowAnimationSetMap)
WindowAnimationSetMap.rend = new_instancemethod(_enigma.WindowAnimationSetMap_rend,None,WindowAnimationSetMap)
WindowAnimationSetMap.count = new_instancemethod(_enigma.WindowAnimationSetMap_count,None,WindowAnimationSetMap)
WindowAnimationSetMap.erase = new_instancemethod(_enigma.WindowAnimationSetMap_erase,None,WindowAnimationSetMap)
WindowAnimationSetMap.find = new_instancemethod(_enigma.WindowAnimationSetMap_find,None,WindowAnimationSetMap)
WindowAnimationSetMap.lower_bound = new_instancemethod(_enigma.WindowAnimationSetMap_lower_bound,None,WindowAnimationSetMap)
WindowAnimationSetMap.upper_bound = new_instancemethod(_enigma.WindowAnimationSetMap_upper_bound,None,WindowAnimationSetMap)
WindowAnimationSetMap_swigregister = _enigma.WindowAnimationSetMap_swigregister
WindowAnimationSetMap_swigregister(WindowAnimationSetMap)

"""
Provides an implementation of a WeakMethodReference
for weak references to functions and methods.

The standard weakref module in Python cannot store
references to non-bound functions and should not
be used to perform this task.

Code borrowed from the following places:

http://code.activestate.com/recipes/81253/
http://stackoverflow.com/questions/3942303/how-does-a-python-set-check-if-two-objects-are-equal-what-methods-does-an-o

Created on 29/02/2012

@author: adam
"""

import weakref
import new

class WeakMethodReference( object ):
    """
    Stores a reference to an object's method or a
    function.

    This class also provides comparison operators to
    allow proper usage in containers such as set([]).

    The ability to change the weak reference is not
    supported to prevent mutability. This is important
    for container support as the object hash would
    change after storing it.
    """

    def __init__(self, function = None ):
        """
        Initialises the weak reference with
        a function or class method.
        """
        object.__init__(self)

        if not callable(function):
            raise AssertionError("ERROR!!! try to create not callable WeakMethodReference", function)

        try:
            if function.im_self is not None:
                # bound method
                self._obj = weakref.ref( function.im_self )
            else:
                # unbound method
                self._obj = None
            self._func = function.im_func
            self._class = function.im_class
        except AttributeError:
            # not a method
            self._obj = None
            self._func = function
            self._class = None

    def __call__( self, *args, **kwargs ):
        """
        @return Returns a new bound-method like the original, or
        the original function if refers just to a function or
        unbound method.
        Returns None if the original object doesn't exist
        """

        if self.is_dead():
            print "dead weakref is not callable!", self
            return None
        if self._obj is not None:
            # we have an instance: return a bound method
            ret = new.instancemethod(
                self._func,
                self._obj(),
                self._class
                )
        else:
            # we don't have an instance: return just the
            # function
            ret = self._func

        return ret(*args, **kwargs)

    def is_dead( self ):
        """
        Returns True if the referenced callable was a bound method and
        the instance no longer exists. Otherwise, return False.
        """
        if self._obj is None and self._func is not None:
            return False
        if self._obj is not None and self._obj() is None:
            return True
        return False

    def is_alive( self ):
        """
        The equivalent to 'not is_dead()'
        Make a positive method call because
        double negatives suck
        """
        return not self.is_dead()

    def __eq__( self, other ):
        """
        Enables comparison between different weak
        pointer objects that point to the same
        object based on the contents instead of the
        object pointer.
        """
        return (
            isinstance(other, self.__class__ ) \
            and self.__dict__ == other.__dict__
            )

    def __ne__( self, other ):
        """
        Enables comparison between different weak
        pointer objects that point to the same
        object based on the contents instead of the
        object pointer.
        """
        return not self.__eq__(other)

    def __hash__( self ):
        """
        this method is provided to allow comparison of
        references inside of containers like set([])

        http://stackoverflow.com/questions/3942303/how-does-a-python-set-check-if-two-objects-are-equal-what-methods-does-an-o

        """
        return hash( (self._obj, self._func, self._class) )

def eServiceReference_create(refstr):
    return eServiceReference(refstr)

class eSlot(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _enigma.delete_eSlot
    def __init__(self): 
        _enigma.eSlot_swiginit(self,_enigma.new_eSlot())
eSlot_swigregister = _enigma.eSlot_swigregister
eSlot_swigregister(eSlot)

class eSlot0X(eSlot):
    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): 
        if self.__class__ == eSlot0X:
            _self = None
        else:
            _self = self
        _enigma.eSlot0X_swiginit(self,_enigma.new_eSlot0X(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot0X
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot0X(self)
        return weakref_proxy(self)
eSlot0X.cb_func = new_instancemethod(_enigma.eSlot0X_cb_func,None,eSlot0X)
eSlot0X_swigregister = _enigma.eSlot0X_swigregister
eSlot0X_swigregister(eSlot0X)

class eSignal0X(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot0X(eSlot0X):
            def __init__(self, func):
                eSlot0X.__init__(self)
                self.cb_func=func
        slot = ePythonSlot0X(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal0X_swiginit(self,_enigma.new_eSignal0X())
    __swig_destroy__ = _enigma.delete_eSignal0X
eSignal0X.connect2 = new_instancemethod(_enigma.eSignal0X_connect2,None,eSignal0X)
eSignal0X_swigregister = _enigma.eSignal0X_swigregister
eSignal0X_swigregister(eSignal0X)

class eSlot1Any(eSlot):
    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): 
        if self.__class__ == eSlot1Any:
            _self = None
        else:
            _self = self
        _enigma.eSlot1Any_swiginit(self,_enigma.new_eSlot1Any(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1Any
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1Any(self)
        return weakref_proxy(self)
eSlot1Any.cb_func = new_instancemethod(_enigma.eSlot1Any_cb_func,None,eSlot1Any)
eSlot1Any_swigregister = _enigma.eSlot1Any_swigregister
eSlot1Any_swigregister(eSlot1Any)

class eSignal1Any(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1Any(eSlot1Any):
            def __init__(self, func):
                eSlot1Any.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1Any(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1Any_swiginit(self,_enigma.new_eSignal1Any())
    __swig_destroy__ = _enigma.delete_eSignal1Any
eSignal1Any.connect2 = new_instancemethod(_enigma.eSignal1Any_connect2,None,eSignal1Any)
eSignal1Any_swigregister = _enigma.eSignal1Any_swigregister
eSignal1Any_swigregister(eSignal1Any)

class eSlot1I(eSlot):
    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): 
        if self.__class__ == eSlot1I:
            _self = None
        else:
            _self = self
        _enigma.eSlot1I_swiginit(self,_enigma.new_eSlot1I(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1I
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1I(self)
        return weakref_proxy(self)
eSlot1I.cb_func = new_instancemethod(_enigma.eSlot1I_cb_func,None,eSlot1I)
eSlot1I_swigregister = _enigma.eSlot1I_swigregister
eSlot1I_swigregister(eSlot1I)

class eSignal1I(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1I(eSlot1I):
            def __init__(self, func):
                eSlot1I.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1I(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1I_swiginit(self,_enigma.new_eSignal1I())
    __swig_destroy__ = _enigma.delete_eSignal1I
eSignal1I.connect2 = new_instancemethod(_enigma.eSignal1I_connect2,None,eSignal1I)
eSignal1I_swigregister = _enigma.eSignal1I_swigregister
eSignal1I_swigregister(eSignal1I)

class eSlot1CStr(eSlot):
    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): 
        if self.__class__ == eSlot1CStr:
            _self = None
        else:
            _self = self
        _enigma.eSlot1CStr_swiginit(self,_enigma.new_eSlot1CStr(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1CStr
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1CStr(self)
        return weakref_proxy(self)
eSlot1CStr.cb_func = new_instancemethod(_enigma.eSlot1CStr_cb_func,None,eSlot1CStr)
eSlot1CStr_swigregister = _enigma.eSlot1CStr_swigregister
eSlot1CStr_swigregister(eSlot1CStr)

class eSignal1CStr(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1CStr(eSlot1CStr):
            def __init__(self, func):
                eSlot1CStr.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1CStr(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1CStr_swiginit(self,_enigma.new_eSignal1CStr())
    __swig_destroy__ = _enigma.delete_eSignal1CStr
eSignal1CStr.connect2 = new_instancemethod(_enigma.eSignal1CStr_connect2,None,eSignal1CStr)
eSignal1CStr_swigregister = _enigma.eSignal1CStr_swigregister
eSignal1CStr_swigregister(eSignal1CStr)

class eSlot1LL(eSlot):
    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): 
        if self.__class__ == eSlot1LL:
            _self = None
        else:
            _self = self
        _enigma.eSlot1LL_swiginit(self,_enigma.new_eSlot1LL(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1LL
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1LL(self)
        return weakref_proxy(self)
eSlot1LL.cb_func = new_instancemethod(_enigma.eSlot1LL_cb_func,None,eSlot1LL)
eSlot1LL_swigregister = _enigma.eSlot1LL_swigregister
eSlot1LL_swigregister(eSlot1LL)

class eSignal1LL(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1LL(eSlot1LL):
            def __init__(self, func):
                eSlot1LL.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1LL(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1LL_swiginit(self,_enigma.new_eSignal1LL())
    __swig_destroy__ = _enigma.delete_eSignal1LL
eSignal1LL.connect2 = new_instancemethod(_enigma.eSignal1LL_connect2,None,eSignal1LL)
eSignal1LL_swigregister = _enigma.eSignal1LL_swigregister
eSignal1LL_swigregister(eSignal1LL)

class eSlot1CStrRCStr(eSlot):
    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): 
        if self.__class__ == eSlot1CStrRCStr:
            _self = None
        else:
            _self = self
        _enigma.eSlot1CStrRCStr_swiginit(self,_enigma.new_eSlot1CStrRCStr(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1CStrRCStr
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1CStrRCStr(self)
        return weakref_proxy(self)
eSlot1CStrRCStr.cb_func = new_instancemethod(_enigma.eSlot1CStrRCStr_cb_func,None,eSlot1CStrRCStr)
eSlot1CStrRCStr_swigregister = _enigma.eSlot1CStrRCStr_swigregister
eSlot1CStrRCStr_swigregister(eSlot1CStrRCStr)

class eSignal1CStrRCStr(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1CStrRCStr(eSlot1CStrRCStr):
            def __init__(self, func):
                eSlot1CStrRCStr.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1CStrRCStr(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1CStrRCStr_swiginit(self,_enigma.new_eSignal1CStrRCStr())
    __swig_destroy__ = _enigma.delete_eSignal1CStrRCStr
eSignal1CStrRCStr.connect2 = new_instancemethod(_enigma.eSignal1CStrRCStr_connect2,None,eSignal1CStrRCStr)
eSignal1CStrRCStr_swigregister = _enigma.eSignal1CStrRCStr_swigregister
eSignal1CStrRCStr_swigregister(eSignal1CStrRCStr)

class eSlot1iDvbFrontendPtr(eSlot):
    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): 
        if self.__class__ == eSlot1iDvbFrontendPtr:
            _self = None
        else:
            _self = self
        _enigma.eSlot1iDvbFrontendPtr_swiginit(self,_enigma.new_eSlot1iDvbFrontendPtr(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1iDvbFrontendPtr
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1iDvbFrontendPtr(self)
        return weakref_proxy(self)
eSlot1iDvbFrontendPtr.cb_func = new_instancemethod(_enigma.eSlot1iDvbFrontendPtr_cb_func,None,eSlot1iDvbFrontendPtr)
eSlot1iDvbFrontendPtr_swigregister = _enigma.eSlot1iDvbFrontendPtr_swigregister
eSlot1iDvbFrontendPtr_swigregister(eSlot1iDvbFrontendPtr)

class eSignal1iDvbFrontendPtr(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1iDvbFrontendPtr(eSlot1iDvbFrontendPtr):
            def __init__(self, func):
                eSlot1iDvbFrontendPtr.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1iDvbFrontendPtr(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1iDvbFrontendPtr_swiginit(self,_enigma.new_eSignal1iDvbFrontendPtr())
    __swig_destroy__ = _enigma.delete_eSignal1iDvbFrontendPtr
eSignal1iDvbFrontendPtr.connect2 = new_instancemethod(_enigma.eSignal1iDvbFrontendPtr_connect2,None,eSignal1iDvbFrontendPtr)
eSignal1iDvbFrontendPtr_swigregister = _enigma.eSignal1iDvbFrontendPtr_swigregister
eSignal1iDvbFrontendPtr_swigregister(eSignal1iDvbFrontendPtr)

class eSlot3IIIRetI(eSlot):
    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): 
        if self.__class__ == eSlot3IIIRetI:
            _self = None
        else:
            _self = self
        _enigma.eSlot3IIIRetI_swiginit(self,_enigma.new_eSlot3IIIRetI(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot3IIIRetI
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot3IIIRetI(self)
        return weakref_proxy(self)
eSlot3IIIRetI.cb_func = new_instancemethod(_enigma.eSlot3IIIRetI_cb_func,None,eSlot3IIIRetI)
eSlot3IIIRetI_swigregister = _enigma.eSlot3IIIRetI_swigregister
eSlot3IIIRetI_swigregister(eSlot3IIIRetI)

class eSignal3IIIRetI(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot3IIIRetI(eSlot3IIIRetI):
            def __init__(self, func):
                eSlot3IIIRetI.__init__(self)
                self.cb_func=func
        slot = ePythonSlot3IIIRetI(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal3IIIRetI_swiginit(self,_enigma.new_eSignal3IIIRetI())
    __swig_destroy__ = _enigma.delete_eSignal3IIIRetI
eSignal3IIIRetI.connect2 = new_instancemethod(_enigma.eSignal3IIIRetI_connect2,None,eSignal3IIIRetI)
eSignal3IIIRetI_swigregister = _enigma.eSignal3IIIRetI_swigregister
eSignal3IIIRetI_swigregister(eSignal3IIIRetI)

class eSlot2IRecordableServicePtrInt(eSlot):
    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): 
        if self.__class__ == eSlot2IRecordableServicePtrInt:
            _self = None
        else:
            _self = self
        _enigma.eSlot2IRecordableServicePtrInt_swiginit(self,_enigma.new_eSlot2IRecordableServicePtrInt(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2IRecordableServicePtrInt
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2IRecordableServicePtrInt(self)
        return weakref_proxy(self)
eSlot2IRecordableServicePtrInt.cb_func = new_instancemethod(_enigma.eSlot2IRecordableServicePtrInt_cb_func,None,eSlot2IRecordableServicePtrInt)
eSlot2IRecordableServicePtrInt_swigregister = _enigma.eSlot2IRecordableServicePtrInt_swigregister
eSlot2IRecordableServicePtrInt_swigregister(eSlot2IRecordableServicePtrInt)

class eSignal2IRecordableServicePtrInt(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot2IRecordableServicePtrInt(eSlot2IRecordableServicePtrInt):
            def __init__(self, func):
                eSlot2IRecordableServicePtrInt.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2IRecordableServicePtrInt(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal2IRecordableServicePtrInt_swiginit(self,_enigma.new_eSignal2IRecordableServicePtrInt())
    __swig_destroy__ = _enigma.delete_eSignal2IRecordableServicePtrInt
eSignal2IRecordableServicePtrInt.connect2 = new_instancemethod(_enigma.eSignal2IRecordableServicePtrInt_connect2,None,eSignal2IRecordableServicePtrInt)
eSignal2IRecordableServicePtrInt_swigregister = _enigma.eSignal2IRecordableServicePtrInt_swigregister
eSignal2IRecordableServicePtrInt_swigregister(eSignal2IRecordableServicePtrInt)

class eSlot1StrMap(eSlot):
    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): 
        if self.__class__ == eSlot1StrMap:
            _self = None
        else:
            _self = self
        _enigma.eSlot1StrMap_swiginit(self,_enigma.new_eSlot1StrMap(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1StrMap
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1StrMap(self)
        return weakref_proxy(self)
eSlot1StrMap.cb_func = new_instancemethod(_enigma.eSlot1StrMap_cb_func,None,eSlot1StrMap)
eSlot1StrMap_swigregister = _enigma.eSlot1StrMap_swigregister
eSlot1StrMap_swigregister(eSlot1StrMap)

class eSignal1StrMap(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1StrMap(eSlot1StrMap):
            def __init__(self, func):
                eSlot1StrMap.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1StrMap(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1StrMap_swiginit(self,_enigma.new_eSignal1StrMap())
    __swig_destroy__ = _enigma.delete_eSignal1StrMap
eSignal1StrMap.connect2 = new_instancemethod(_enigma.eSignal1StrMap_connect2,None,eSignal1StrMap)
eSignal1StrMap_swigregister = _enigma.eSignal1StrMap_swigregister
eSignal1StrMap_swigregister(eSignal1StrMap)

class eSlot2StrMapBool(eSlot):
    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): 
        if self.__class__ == eSlot2StrMapBool:
            _self = None
        else:
            _self = self
        _enigma.eSlot2StrMapBool_swiginit(self,_enigma.new_eSlot2StrMapBool(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2StrMapBool
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2StrMapBool(self)
        return weakref_proxy(self)
eSlot2StrMapBool.cb_func = new_instancemethod(_enigma.eSlot2StrMapBool_cb_func,None,eSlot2StrMapBool)
eSlot2StrMapBool_swigregister = _enigma.eSlot2StrMapBool_swigregister
eSlot2StrMapBool_swigregister(eSlot2StrMapBool)

class eSignal2StrMapBool(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot2StrMapBool(eSlot2StrMapBool):
            def __init__(self, func):
                eSlot2StrMapBool.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2StrMapBool(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal2StrMapBool_swiginit(self,_enigma.new_eSignal2StrMapBool())
    __swig_destroy__ = _enigma.delete_eSignal2StrMapBool
eSignal2StrMapBool.connect2 = new_instancemethod(_enigma.eSignal2StrMapBool_connect2,None,eSignal2StrMapBool)
eSignal2StrMapBool_swigregister = _enigma.eSignal2StrMapBool_swigregister
eSignal2StrMapBool_swigregister(eSignal2StrMapBool)

class eSlot2StrMapStrSet(eSlot):
    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): 
        if self.__class__ == eSlot2StrMapStrSet:
            _self = None
        else:
            _self = self
        _enigma.eSlot2StrMapStrSet_swiginit(self,_enigma.new_eSlot2StrMapStrSet(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2StrMapStrSet
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2StrMapStrSet(self)
        return weakref_proxy(self)
eSlot2StrMapStrSet.cb_func = new_instancemethod(_enigma.eSlot2StrMapStrSet_cb_func,None,eSlot2StrMapStrSet)
eSlot2StrMapStrSet_swigregister = _enigma.eSlot2StrMapStrSet_swigregister
eSlot2StrMapStrSet_swigregister(eSlot2StrMapStrSet)

class eSignal2StrMapStrSet(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot2StrMapStrSet(eSlot2StrMapStrSet):
            def __init__(self, func):
                eSlot2StrMapStrSet.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2StrMapStrSet(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal2StrMapStrSet_swiginit(self,_enigma.new_eSignal2StrMapStrSet())
    __swig_destroy__ = _enigma.delete_eSignal2StrMapStrSet
eSignal2StrMapStrSet.connect2 = new_instancemethod(_enigma.eSignal2StrMapStrSet_connect2,None,eSignal2StrMapStrSet)
eSignal2StrMapStrSet_swigregister = _enigma.eSignal2StrMapStrSet_swigregister
eSignal2StrMapStrSet_swigregister(eSignal2StrMapStrSet)

class eSlot2StrMapStrMapVector(eSlot):
    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): 
        if self.__class__ == eSlot2StrMapStrMapVector:
            _self = None
        else:
            _self = self
        _enigma.eSlot2StrMapStrMapVector_swiginit(self,_enigma.new_eSlot2StrMapStrMapVector(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2StrMapStrMapVector
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2StrMapStrMapVector(self)
        return weakref_proxy(self)
eSlot2StrMapStrMapVector.cb_func = new_instancemethod(_enigma.eSlot2StrMapStrMapVector_cb_func,None,eSlot2StrMapStrMapVector)
eSlot2StrMapStrMapVector_swigregister = _enigma.eSlot2StrMapStrMapVector_swigregister
eSlot2StrMapStrMapVector_swigregister(eSlot2StrMapStrMapVector)

class eSignal2StrMapStrMapVector(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot2StrMapStrMapVector(eSlot2StrMapStrMapVector):
            def __init__(self, func):
                eSlot2StrMapStrMapVector.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2StrMapStrMapVector(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal2StrMapStrMapVector_swiginit(self,_enigma.new_eSignal2StrMapStrMapVector())
    __swig_destroy__ = _enigma.delete_eSignal2StrMapStrMapVector
eSignal2StrMapStrMapVector.connect2 = new_instancemethod(_enigma.eSignal2StrMapStrMapVector_connect2,None,eSignal2StrMapStrMapVector)
eSignal2StrMapStrMapVector_swigregister = _enigma.eSignal2StrMapStrMapVector_swigregister
eSignal2StrMapStrMapVector_swigregister(eSignal2StrMapStrMapVector)

class eSlot3StrMapLLLL(eSlot):
    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): 
        if self.__class__ == eSlot3StrMapLLLL:
            _self = None
        else:
            _self = self
        _enigma.eSlot3StrMapLLLL_swiginit(self,_enigma.new_eSlot3StrMapLLLL(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot3StrMapLLLL
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot3StrMapLLLL(self)
        return weakref_proxy(self)
eSlot3StrMapLLLL.cb_func = new_instancemethod(_enigma.eSlot3StrMapLLLL_cb_func,None,eSlot3StrMapLLLL)
eSlot3StrMapLLLL_swigregister = _enigma.eSlot3StrMapLLLL_swigregister
eSlot3StrMapLLLL_swigregister(eSlot3StrMapLLLL)

class eSignal3StrMapLLLL(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot3StrMapLLLL(eSlot3StrMapLLLL):
            def __init__(self, func):
                eSlot3StrMapLLLL.__init__(self)
                self.cb_func=func
        slot = ePythonSlot3StrMapLLLL(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal3StrMapLLLL_swiginit(self,_enigma.new_eSignal3StrMapLLLL())
    __swig_destroy__ = _enigma.delete_eSignal3StrMapLLLL
eSignal3StrMapLLLL.connect2 = new_instancemethod(_enigma.eSignal3StrMapLLLL_connect2,None,eSignal3StrMapLLLL)
eSignal3StrMapLLLL_swigregister = _enigma.eSignal3StrMapLLLL_swigregister
eSignal3StrMapLLLL_swigregister(eSignal3StrMapLLLL)

class eSlot3StrMapStrMapVectorStrList(eSlot):
    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): 
        if self.__class__ == eSlot3StrMapStrMapVectorStrList:
            _self = None
        else:
            _self = self
        _enigma.eSlot3StrMapStrMapVectorStrList_swiginit(self,_enigma.new_eSlot3StrMapStrMapVectorStrList(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot3StrMapStrMapVectorStrList
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot3StrMapStrMapVectorStrList(self)
        return weakref_proxy(self)
eSlot3StrMapStrMapVectorStrList.cb_func = new_instancemethod(_enigma.eSlot3StrMapStrMapVectorStrList_cb_func,None,eSlot3StrMapStrMapVectorStrList)
eSlot3StrMapStrMapVectorStrList_swigregister = _enigma.eSlot3StrMapStrMapVectorStrList_swigregister
eSlot3StrMapStrMapVectorStrList_swigregister(eSlot3StrMapStrMapVectorStrList)

class eSignal3StrMapStrMapVectorStrList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot3StrMapStrMapVectorStrList(eSlot3StrMapStrMapVectorStrList):
            def __init__(self, func):
                eSlot3StrMapStrMapVectorStrList.__init__(self)
                self.cb_func=func
        slot = ePythonSlot3StrMapStrMapVectorStrList(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal3StrMapStrMapVectorStrList_swiginit(self,_enigma.new_eSignal3StrMapStrMapVectorStrList())
    __swig_destroy__ = _enigma.delete_eSignal3StrMapStrMapVectorStrList
eSignal3StrMapStrMapVectorStrList.connect2 = new_instancemethod(_enigma.eSignal3StrMapStrMapVectorStrList_connect2,None,eSignal3StrMapStrMapVectorStrList)
eSignal3StrMapStrMapVectorStrList_swigregister = _enigma.eSignal3StrMapStrMapVectorStrList_swigregister
eSignal3StrMapStrMapVectorStrList_swigregister(eSignal3StrMapStrMapVectorStrList)

class eSlot2IntAny(eSlot):
    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): 
        if self.__class__ == eSlot2IntAny:
            _self = None
        else:
            _self = self
        _enigma.eSlot2IntAny_swiginit(self,_enigma.new_eSlot2IntAny(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2IntAny
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2IntAny(self)
        return weakref_proxy(self)
eSlot2IntAny.cb_func = new_instancemethod(_enigma.eSlot2IntAny_cb_func,None,eSlot2IntAny)
eSlot2IntAny_swigregister = _enigma.eSlot2IntAny_swigregister
eSlot2IntAny_swigregister(eSlot2IntAny)

class eSignal2IntAny(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot2IntAny(eSlot2IntAny):
            def __init__(self, func):
                eSlot2IntAny.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2IntAny(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal2IntAny_swiginit(self,_enigma.new_eSignal2IntAny())
    __swig_destroy__ = _enigma.delete_eSignal2IntAny
eSignal2IntAny.connect2 = new_instancemethod(_enigma.eSignal2IntAny_connect2,None,eSignal2IntAny)
eSignal2IntAny_swigregister = _enigma.eSignal2IntAny_swigregister
eSignal2IntAny_swigregister(eSignal2IntAny)

class eSlot4StrUInt64UInt64UInt64(eSlot):
    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): 
        if self.__class__ == eSlot4StrUInt64UInt64UInt64:
            _self = None
        else:
            _self = self
        _enigma.eSlot4StrUInt64UInt64UInt64_swiginit(self,_enigma.new_eSlot4StrUInt64UInt64UInt64(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot4StrUInt64UInt64UInt64
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot4StrUInt64UInt64UInt64(self)
        return weakref_proxy(self)
eSlot4StrUInt64UInt64UInt64.cb_func = new_instancemethod(_enigma.eSlot4StrUInt64UInt64UInt64_cb_func,None,eSlot4StrUInt64UInt64UInt64)
eSlot4StrUInt64UInt64UInt64_swigregister = _enigma.eSlot4StrUInt64UInt64UInt64_swigregister
eSlot4StrUInt64UInt64UInt64_swigregister(eSlot4StrUInt64UInt64UInt64)

class eSignal4StrUInt64UInt64UInt64(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot4StrUInt64UInt64UInt64(eSlot4StrUInt64UInt64UInt64):
            def __init__(self, func):
                eSlot4StrUInt64UInt64UInt64.__init__(self)
                self.cb_func=func
        slot = ePythonSlot4StrUInt64UInt64UInt64(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal4StrUInt64UInt64UInt64_swiginit(self,_enigma.new_eSignal4StrUInt64UInt64UInt64())
    __swig_destroy__ = _enigma.delete_eSignal4StrUInt64UInt64UInt64
eSignal4StrUInt64UInt64UInt64.connect2 = new_instancemethod(_enigma.eSignal4StrUInt64UInt64UInt64_connect2,None,eSignal4StrUInt64UInt64UInt64)
eSignal4StrUInt64UInt64UInt64_swigregister = _enigma.eSignal4StrUInt64UInt64UInt64_swigregister
eSignal4StrUInt64UInt64UInt64_swigregister(eSignal4StrUInt64UInt64UInt64)

class eSlot4UInt64UInt64UInt64IntList(eSlot):
    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): 
        if self.__class__ == eSlot4UInt64UInt64UInt64IntList:
            _self = None
        else:
            _self = self
        _enigma.eSlot4UInt64UInt64UInt64IntList_swiginit(self,_enigma.new_eSlot4UInt64UInt64UInt64IntList(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot4UInt64UInt64UInt64IntList
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot4UInt64UInt64UInt64IntList(self)
        return weakref_proxy(self)
eSlot4UInt64UInt64UInt64IntList.cb_func = new_instancemethod(_enigma.eSlot4UInt64UInt64UInt64IntList_cb_func,None,eSlot4UInt64UInt64UInt64IntList)
eSlot4UInt64UInt64UInt64IntList_swigregister = _enigma.eSlot4UInt64UInt64UInt64IntList_swigregister
eSlot4UInt64UInt64UInt64IntList_swigregister(eSlot4UInt64UInt64UInt64IntList)

class eSignal4UInt64UInt64UInt64IntList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot4UInt64UInt64UInt64IntList(eSlot4UInt64UInt64UInt64IntList):
            def __init__(self, func):
                eSlot4UInt64UInt64UInt64IntList.__init__(self)
                self.cb_func=func
        slot = ePythonSlot4UInt64UInt64UInt64IntList(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal4UInt64UInt64UInt64IntList_swiginit(self,_enigma.new_eSignal4UInt64UInt64UInt64IntList())
    __swig_destroy__ = _enigma.delete_eSignal4UInt64UInt64UInt64IntList
eSignal4UInt64UInt64UInt64IntList.connect2 = new_instancemethod(_enigma.eSignal4UInt64UInt64UInt64IntList_connect2,None,eSignal4UInt64UInt64UInt64IntList)
eSignal4UInt64UInt64UInt64IntList_swigregister = _enigma.eSignal4UInt64UInt64UInt64IntList_swigregister
eSignal4UInt64UInt64UInt64IntList_swigregister(eSignal4UInt64UInt64UInt64IntList)

class eSlot5CStrUInt64UInt64UInt64Int(eSlot):
    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): 
        if self.__class__ == eSlot5CStrUInt64UInt64UInt64Int:
            _self = None
        else:
            _self = self
        _enigma.eSlot5CStrUInt64UInt64UInt64Int_swiginit(self,_enigma.new_eSlot5CStrUInt64UInt64UInt64Int(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot5CStrUInt64UInt64UInt64Int
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot5CStrUInt64UInt64UInt64Int(self)
        return weakref_proxy(self)
eSlot5CStrUInt64UInt64UInt64Int.cb_func = new_instancemethod(_enigma.eSlot5CStrUInt64UInt64UInt64Int_cb_func,None,eSlot5CStrUInt64UInt64UInt64Int)
eSlot5CStrUInt64UInt64UInt64Int_swigregister = _enigma.eSlot5CStrUInt64UInt64UInt64Int_swigregister
eSlot5CStrUInt64UInt64UInt64Int_swigregister(eSlot5CStrUInt64UInt64UInt64Int)

class eSignal5CStrUInt64UInt64UInt64Int(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot5CStrUInt64UInt64UInt64Int(eSlot5CStrUInt64UInt64UInt64Int):
            def __init__(self, func):
                eSlot5CStrUInt64UInt64UInt64Int.__init__(self)
                self.cb_func=func
        slot = ePythonSlot5CStrUInt64UInt64UInt64Int(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal5CStrUInt64UInt64UInt64Int_swiginit(self,_enigma.new_eSignal5CStrUInt64UInt64UInt64Int())
    __swig_destroy__ = _enigma.delete_eSignal5CStrUInt64UInt64UInt64Int
eSignal5CStrUInt64UInt64UInt64Int.connect2 = new_instancemethod(_enigma.eSignal5CStrUInt64UInt64UInt64Int_connect2,None,eSignal5CStrUInt64UInt64UInt64Int)
eSignal5CStrUInt64UInt64UInt64Int_swigregister = _enigma.eSignal5CStrUInt64UInt64UInt64Int_swigregister
eSignal5CStrUInt64UInt64UInt64Int_swigregister(eSignal5CStrUInt64UInt64UInt64Int)

class eSlot1Bool(eSlot):
    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): 
        if self.__class__ == eSlot1Bool:
            _self = None
        else:
            _self = self
        _enigma.eSlot1Bool_swiginit(self,_enigma.new_eSlot1Bool(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1Bool
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1Bool(self)
        return weakref_proxy(self)
eSlot1Bool.cb_func = new_instancemethod(_enigma.eSlot1Bool_cb_func,None,eSlot1Bool)
eSlot1Bool_swigregister = _enigma.eSlot1Bool_swigregister
eSlot1Bool_swigregister(eSlot1Bool)

class eSignal1Bool(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1Bool(eSlot1Bool):
            def __init__(self, func):
                eSlot1Bool.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1Bool(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1Bool_swiginit(self,_enigma.new_eSignal1Bool())
    __swig_destroy__ = _enigma.delete_eSignal1Bool
eSignal1Bool.connect2 = new_instancemethod(_enigma.eSignal1Bool_connect2,None,eSignal1Bool)
eSignal1Bool_swigregister = _enigma.eSignal1Bool_swigregister
eSignal1Bool_swigregister(eSignal1Bool)

class eSlot1Str(eSlot):
    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): 
        if self.__class__ == eSlot1Str:
            _self = None
        else:
            _self = self
        _enigma.eSlot1Str_swiginit(self,_enigma.new_eSlot1Str(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1Str
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1Str(self)
        return weakref_proxy(self)
eSlot1Str.cb_func = new_instancemethod(_enigma.eSlot1Str_cb_func,None,eSlot1Str)
eSlot1Str_swigregister = _enigma.eSlot1Str_swigregister
eSlot1Str_swigregister(eSlot1Str)

class eSignal1Str(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1Str(eSlot1Str):
            def __init__(self, func):
                eSlot1Str.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1Str(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1Str_swiginit(self,_enigma.new_eSignal1Str())
    __swig_destroy__ = _enigma.delete_eSignal1Str
eSignal1Str.connect2 = new_instancemethod(_enigma.eSignal1Str_connect2,None,eSignal1Str)
eSignal1Str_swigregister = _enigma.eSignal1Str_swigregister
eSignal1Str_swigregister(eSignal1Str)

class eSlot1NetworkService(eSlot):
    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): 
        if self.__class__ == eSlot1NetworkService:
            _self = None
        else:
            _self = self
        _enigma.eSlot1NetworkService_swiginit(self,_enigma.new_eSlot1NetworkService(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1NetworkService
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1NetworkService(self)
        return weakref_proxy(self)
eSlot1NetworkService.cb_func = new_instancemethod(_enigma.eSlot1NetworkService_cb_func,None,eSlot1NetworkService)
eSlot1NetworkService_swigregister = _enigma.eSlot1NetworkService_swigregister
eSlot1NetworkService_swigregister(eSlot1NetworkService)

class eSignal1NetworkService(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1NetworkService(eSlot1NetworkService):
            def __init__(self, func):
                eSlot1NetworkService.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1NetworkService(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1NetworkService_swiginit(self,_enigma.new_eSignal1NetworkService())
    __swig_destroy__ = _enigma.delete_eSignal1NetworkService
eSignal1NetworkService.connect2 = new_instancemethod(_enigma.eSignal1NetworkService_connect2,None,eSignal1NetworkService)
eSignal1NetworkService_swigregister = _enigma.eSignal1NetworkService_swigregister
eSignal1NetworkService_swigregister(eSignal1NetworkService)

class eSlot1StringList(eSlot):
    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): 
        if self.__class__ == eSlot1StringList:
            _self = None
        else:
            _self = self
        _enigma.eSlot1StringList_swiginit(self,_enigma.new_eSlot1StringList(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1StringList
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1StringList(self)
        return weakref_proxy(self)
eSlot1StringList.cb_func = new_instancemethod(_enigma.eSlot1StringList_cb_func,None,eSlot1StringList)
eSlot1StringList_swigregister = _enigma.eSlot1StringList_swigregister
eSlot1StringList_swigregister(eSlot1StringList)

class eSignal1StringList(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1StringList(eSlot1StringList):
            def __init__(self, func):
                eSlot1StringList.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1StringList(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1StringList_swiginit(self,_enigma.new_eSignal1StringList())
    __swig_destroy__ = _enigma.delete_eSignal1StringList
eSignal1StringList.connect2 = new_instancemethod(_enigma.eSignal1StringList_connect2,None,eSignal1StringList)
eSignal1StringList_swigregister = _enigma.eSignal1StringList_swigregister
eSignal1StringList_swigregister(eSignal1StringList)

class eSlot2StrMapStrAny(eSlot):
    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): 
        if self.__class__ == eSlot2StrMapStrAny:
            _self = None
        else:
            _self = self
        _enigma.eSlot2StrMapStrAny_swiginit(self,_enigma.new_eSlot2StrMapStrAny(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2StrMapStrAny
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2StrMapStrAny(self)
        return weakref_proxy(self)
eSlot2StrMapStrAny.cb_func = new_instancemethod(_enigma.eSlot2StrMapStrAny_cb_func,None,eSlot2StrMapStrAny)
eSlot2StrMapStrAny_swigregister = _enigma.eSlot2StrMapStrAny_swigregister
eSlot2StrMapStrAny_swigregister(eSlot2StrMapStrAny)

class eSignal2StrMapStrAny(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot2StrMapStrAny(eSlot2StrMapStrAny):
            def __init__(self, func):
                eSlot2StrMapStrAny.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2StrMapStrAny(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal2StrMapStrAny_swiginit(self,_enigma.new_eSignal2StrMapStrAny())
    __swig_destroy__ = _enigma.delete_eSignal2StrMapStrAny
eSignal2StrMapStrAny.connect2 = new_instancemethod(_enigma.eSignal2StrMapStrAny_connect2,None,eSignal2StrMapStrAny)
eSignal2StrMapStrAny_swigregister = _enigma.eSignal2StrMapStrAny_swigregister
eSignal2StrMapStrAny_swigregister(eSignal2StrMapStrAny)

class eSlot2StrStr(eSlot):
    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): 
        if self.__class__ == eSlot2StrStr:
            _self = None
        else:
            _self = self
        _enigma.eSlot2StrStr_swiginit(self,_enigma.new_eSlot2StrStr(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2StrStr
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2StrStr(self)
        return weakref_proxy(self)
eSlot2StrStr.cb_func = new_instancemethod(_enigma.eSlot2StrStr_cb_func,None,eSlot2StrStr)
eSlot2StrStr_swigregister = _enigma.eSlot2StrStr_swigregister
eSlot2StrStr_swigregister(eSlot2StrStr)

class eSignal2StrStr(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot2StrStr(eSlot2StrStr):
            def __init__(self, func):
                eSlot2StrStr.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2StrStr(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal2StrStr_swiginit(self,_enigma.new_eSignal2StrStr())
    __swig_destroy__ = _enigma.delete_eSignal2StrStr
eSignal2StrStr.connect2 = new_instancemethod(_enigma.eSignal2StrStr_connect2,None,eSignal2StrStr)
eSignal2StrStr_swigregister = _enigma.eSignal2StrStr_swigregister
eSignal2StrStr_swigregister(eSignal2StrStr)

class eSlot1UInt(eSlot):
    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): 
        if self.__class__ == eSlot1UInt:
            _self = None
        else:
            _self = self
        _enigma.eSlot1UInt_swiginit(self,_enigma.new_eSlot1UInt(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1UInt
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1UInt(self)
        return weakref_proxy(self)
eSlot1UInt.cb_func = new_instancemethod(_enigma.eSlot1UInt_cb_func,None,eSlot1UInt)
eSlot1UInt_swigregister = _enigma.eSlot1UInt_swigregister
eSlot1UInt_swigregister(eSlot1UInt)

class eSignal1UInt(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1UInt(eSlot1UInt):
            def __init__(self, func):
                eSlot1UInt.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1UInt(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1UInt_swiginit(self,_enigma.new_eSignal1UInt())
    __swig_destroy__ = _enigma.delete_eSignal1UInt
eSignal1UInt.connect2 = new_instancemethod(_enigma.eSignal1UInt_connect2,None,eSignal1UInt)
eSignal1UInt_swigregister = _enigma.eSignal1UInt_swigregister
eSignal1UInt_swigregister(eSignal1UInt)

class eSlot1MapStrAny(eSlot):
    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): 
        if self.__class__ == eSlot1MapStrAny:
            _self = None
        else:
            _self = self
        _enigma.eSlot1MapStrAny_swiginit(self,_enigma.new_eSlot1MapStrAny(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1MapStrAny
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1MapStrAny(self)
        return weakref_proxy(self)
eSlot1MapStrAny.cb_func = new_instancemethod(_enigma.eSlot1MapStrAny_cb_func,None,eSlot1MapStrAny)
eSlot1MapStrAny_swigregister = _enigma.eSlot1MapStrAny_swigregister
eSlot1MapStrAny_swigregister(eSlot1MapStrAny)

class eSignal1MapStrAny(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1MapStrAny(eSlot1MapStrAny):
            def __init__(self, func):
                eSlot1MapStrAny.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1MapStrAny(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1MapStrAny_swiginit(self,_enigma.new_eSignal1MapStrAny())
    __swig_destroy__ = _enigma.delete_eSignal1MapStrAny
eSignal1MapStrAny.connect2 = new_instancemethod(_enigma.eSignal1MapStrAny_connect2,None,eSignal1MapStrAny)
eSignal1MapStrAny_swigregister = _enigma.eSignal1MapStrAny_swigregister
eSignal1MapStrAny_swigregister(eSignal1MapStrAny)

class eSlot1UInt32(eSlot):
    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): 
        if self.__class__ == eSlot1UInt32:
            _self = None
        else:
            _self = self
        _enigma.eSlot1UInt32_swiginit(self,_enigma.new_eSlot1UInt32(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot1UInt32
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot1UInt32(self)
        return weakref_proxy(self)
eSlot1UInt32.cb_func = new_instancemethod(_enigma.eSlot1UInt32_cb_func,None,eSlot1UInt32)
eSlot1UInt32_swigregister = _enigma.eSlot1UInt32_swigregister
eSlot1UInt32_swigregister(eSlot1UInt32)

class eSignal1UInt32(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot1UInt32(eSlot1UInt32):
            def __init__(self, func):
                eSlot1UInt32.__init__(self)
                self.cb_func=func
        slot = ePythonSlot1UInt32(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal1UInt32_swiginit(self,_enigma.new_eSignal1UInt32())
    __swig_destroy__ = _enigma.delete_eSignal1UInt32
eSignal1UInt32.connect2 = new_instancemethod(_enigma.eSignal1UInt32_connect2,None,eSignal1UInt32)
eSignal1UInt32_swigregister = _enigma.eSignal1UInt32_swigregister
eSignal1UInt32_swigregister(eSignal1UInt32)

class eSlot4UIntUIntUIntUInt(eSlot):
    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): 
        if self.__class__ == eSlot4UIntUIntUIntUInt:
            _self = None
        else:
            _self = self
        _enigma.eSlot4UIntUIntUIntUInt_swiginit(self,_enigma.new_eSlot4UIntUIntUIntUInt(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot4UIntUIntUIntUInt
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot4UIntUIntUIntUInt(self)
        return weakref_proxy(self)
eSlot4UIntUIntUIntUInt.cb_func = new_instancemethod(_enigma.eSlot4UIntUIntUIntUInt_cb_func,None,eSlot4UIntUIntUIntUInt)
eSlot4UIntUIntUIntUInt_swigregister = _enigma.eSlot4UIntUIntUIntUInt_swigregister
eSlot4UIntUIntUIntUInt_swigregister(eSlot4UIntUIntUIntUInt)

class eSignal4UIntUIntUIntUInt(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def connect(self, func):
        class ePythonSlot4UIntUIntUIntUInt(eSlot4UIntUIntUIntUInt):
            def __init__(self, func):
                eSlot4UIntUIntUIntUInt.__init__(self)
                self.cb_func=func
        slot = ePythonSlot4UIntUIntUIntUInt(WeakMethodReference(func))
        self.connect2(slot)
        return slot
    def __init__(self): 
        _enigma.eSignal4UIntUIntUIntUInt_swiginit(self,_enigma.new_eSignal4UIntUIntUIntUInt())
    __swig_destroy__ = _enigma.delete_eSignal4UIntUIntUIntUInt
eSignal4UIntUIntUIntUInt.connect2 = new_instancemethod(_enigma.eSignal4UIntUIntUIntUInt_connect2,None,eSignal4UIntUIntUIntUInt)
eSignal4UIntUIntUIntUInt_swigregister = _enigma.eSignal4UIntUIntUIntUInt_swigregister
eSignal4UIntUIntUIntUInt_swigregister(eSignal4UIntUIntUIntUInt)


def getBestPlayableServiceReference(*args):
  return _enigma.getBestPlayableServiceReference(*args)
getBestPlayableServiceReference = _enigma.getBestPlayableServiceReference

def setTunerTypePriorityOrder(*args):
  return _enigma.setTunerTypePriorityOrder(*args)
setTunerTypePriorityOrder = _enigma.setTunerTypePriorityOrder

def getExitCode():
  return _enigma.getExitCode()
getExitCode = _enigma.getExitCode

def addFont(*args):
  return _enigma.addFont(*args)
addFont = _enigma.addFont

def getPrevAsciiCode():
  return _enigma.getPrevAsciiCode()
getPrevAsciiCode = _enigma.getPrevAsciiCode

def runMainloop():
  return _enigma.runMainloop()
runMainloop = _enigma.runMainloop

def quitMainloop(*args):
  return _enigma.quitMainloop(*args)
quitMainloop = _enigma.quitMainloop

def getEnigmaVersionString():
  return _enigma.getEnigmaVersionString()
getEnigmaVersionString = _enigma.getEnigmaVersionString

def dump_malloc_stats():
  return _enigma.dump_malloc_stats()
dump_malloc_stats = _enigma.dump_malloc_stats


