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

from sys import version_info as _swig_python_version_info
if _swig_python_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 _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_enigma')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_enigma')
    _enigma = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_enigma', [dirname(__file__)])
        except ImportError:
            import _enigma
            return _enigma
        try:
            _mod = imp.load_module('_enigma', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _enigma = swig_import_helper()
    del swig_import_helper
else:
    import _enigma
del _swig_python_version_info

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.Exception:
    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_ALSA_AUDIO = _enigma.ENABLE_ALSA_AUDIO
ENABLE_EWEBVIEW = _enigma.ENABLE_EWEBVIEW
ENABLE_SVG = _enigma.ENABLE_SVG
HAVE_BOOST = _enigma.HAVE_BOOST
HAVE_BOOST_ALGORITHM_STRING_HPP = _enigma.HAVE_BOOST_ALGORITHM_STRING_HPP
HAVE_BOOST_FORMAT_HPP = _enigma.HAVE_BOOST_FORMAT_HPP
HAVE_CXX14 = _enigma.HAVE_CXX14
HAVE_DATE_DATE_H = _enigma.HAVE_DATE_DATE_H
HAVE_DLFCN_H = _enigma.HAVE_DLFCN_H
HAVE_DRM_DRM_FOURCC_H = _enigma.HAVE_DRM_DRM_FOURCC_H
HAVE_EGL_EGLEXT_H = _enigma.HAVE_EGL_EGLEXT_H
HAVE_EGL_EGL_H = _enigma.HAVE_EGL_EGL_H
HAVE_GLES2_GL2EXT_H = _enigma.HAVE_GLES2_GL2EXT_H
HAVE_GLES2_GL2_H = _enigma.HAVE_GLES2_GL2_H
HAVE_GLES3_GL31_H = _enigma.HAVE_GLES3_GL31_H
HAVE_GLES3_GL32_H = _enigma.HAVE_GLES3_GL32_H
HAVE_GLES3_GL3_H = _enigma.HAVE_GLES3_GL3_H
HAVE_GST_1 = _enigma.HAVE_GST_1
HAVE_GST_STREAM_FLAG_FORCED = _enigma.HAVE_GST_STREAM_FLAG_FORCED
HAVE_INTTYPES_H = _enigma.HAVE_INTTYPES_H
HAVE_LIBSYSTEMD = _enigma.HAVE_LIBSYSTEMD
HAVE_LIBTURBOJPEG = _enigma.HAVE_LIBTURBOJPEG
HAVE_LIBUNWIND_H = _enigma.HAVE_LIBUNWIND_H
HAVE_MEMORY_H = _enigma.HAVE_MEMORY_H
HAVE_PTHREAD = _enigma.HAVE_PTHREAD
HAVE_PTHREAD_PRIO_INHERIT = _enigma.HAVE_PTHREAD_PRIO_INHERIT
HAVE_PYTHON = _enigma.HAVE_PYTHON
HAVE_QT = _enigma.HAVE_QT
HAVE_QT_GUI = _enigma.HAVE_QT_GUI
HAVE_QT_OPENGL = _enigma.HAVE_QT_OPENGL
HAVE_QWEBSETTINGS_WEBSECURITY_ENABLED = _enigma.HAVE_QWEBSETTINGS_WEBSECURITY_ENABLED
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_WEBM_WEBM_PARSER_H = _enigma.HAVE_WEBM_WEBM_PARSER_H
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
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)

HASH_MAP_INCLUDE = _enigma.HASH_MAP_INCLUDE
HASH_SET_INCLUDE = _enigma.HASH_SET_INCLUDE
USE_FAST_HASH = _enigma.USE_FAST_HASH
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

    def runLoop(self):
        """runLoop(eMainloop self) -> int"""
        return _enigma.eMainloop_runLoop(self)


    def isIdle(self):
        """isIdle(eMainloop self) -> int"""
        return _enigma.eMainloop_isIdle(self)


    def idleCount(self):
        """idleCount(eMainloop self) -> int"""
        return _enigma.eMainloop_idleCount(self)


    def tid(self):
        """tid(eMainloop self) -> pid_t"""
        return _enigma.eMainloop_tid(self)


    def argc(self):
        """argc(eMainloop self) -> int &"""
        return _enigma.eMainloop_argc(self)


    def argv(self):
        """argv(eMainloop self) -> char **"""
        return _enigma.eMainloop_argv(self)

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.tid = new_instancemethod(_enigma.eMainloop_tid, 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 start(self):
        """start(eSocketNotifier self)"""
        return _enigma.eSocketNotifier_start(self)


    def stop(self):
        """stop(eSocketNotifier self)"""
        return _enigma.eSocketNotifier_stop(self)


    def isRunning(self):
        """isRunning(eSocketNotifier self) -> bool"""
        return _enigma.eSocketNotifier_isRunning(self)


    def getFD(self):
        """getFD(eSocketNotifier self) -> int"""
        return _enigma.eSocketNotifier_getFD(self)


    def getRequested(self):
        """getRequested(eSocketNotifier self) -> int"""
        return _enigma.eSocketNotifier_getRequested(self)


    def setRequested(self, req):
        """setRequested(eSocketNotifier self, int req)"""
        return _enigma.eSocketNotifier_setRequested(self, req)


    def getState(self):
        """getState(eSocketNotifier self) -> int"""
        return _enigma.eSocketNotifier_getState(self)


    def activate(self, what):
        """activate(eSocketNotifier self, int what)"""
        return _enigma.eSocketNotifier_activate(self, what)


    def getContext(self):
        """getContext(eSocketNotifier self) -> eMainloop"""
        return _enigma.eSocketNotifier_getContext(self)


    def __init__(self, fd, req, startNow=True):
        """
        __init__(eSocketNotifier self, int fd, int req, bool startNow=True) -> eSocketNotifier
        __init__(eSocketNotifier self, int fd, int req) -> eSocketNotifier
        """
        _enigma.eSocketNotifier_swiginit(self, _enigma.new_eSocketNotifier(fd, req, startNow))
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.getContext = new_instancemethod(_enigma.eSocketNotifier_getContext, 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 isActive(self):
        """isActive(eTimer self) -> bool"""
        return _enigma.eTimer_isActive(self)


    def getNextActivation(self):
        """getNextActivation(eTimer self) -> timespec &"""
        return _enigma.eTimer_getNextActivation(self)


    def getInterval(self):
        """getInterval(eTimer self) -> int"""
        return _enigma.eTimer_getInterval(self)


    def activate(self):
        """activate(eTimer self)"""
        return _enigma.eTimer_activate(self)


    def start(self, msec, b=False):
        """
        start(eTimer self, int msec, bool b=False)
        start(eTimer self, int msec)
        """
        return _enigma.eTimer_start(self, msec, b)


    def stop(self):
        """stop(eTimer self)"""
        return _enigma.eTimer_stop(self)


    def changeInterval(self, msek):
        """changeInterval(eTimer self, int msek)"""
        return _enigma.eTimer_changeInterval(self, msek)


    def startLongTimer(self, seconds):
        """startLongTimer(eTimer self, int seconds)"""
        return _enigma.eTimer_startLongTimer(self, seconds)


    def __init__(self):
        """__init__(eTimer self) -> eTimer"""
        _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):
        """__init__(eConsoleAppContainer self) -> eConsoleAppContainer"""
        _enigma.eConsoleAppContainer_swiginit(self, _enigma.new_eConsoleAppContainer())
    __swig_destroy__ = _enigma.delete_eConsoleAppContainer

    def setCWD(self, path):
        """setCWD(eConsoleAppContainer self, char const * path) -> int"""
        return _enigma.eConsoleAppContainer_setCWD(self, path)


    def exec1(self, str):
        """exec1(eConsoleAppContainer self, char const * str) -> int"""
        return _enigma.eConsoleAppContainer_exec1(self, str)


    def exec2(self, cmdline, argv):
        """exec2(eConsoleAppContainer self, char const * cmdline, char const *const [] argv) -> int"""
        return _enigma.eConsoleAppContainer_exec2(self, cmdline, argv)


    def getPID(self):
        """getPID(eConsoleAppContainer self) -> int"""
        return _enigma.eConsoleAppContainer_getPID(self)


    def kill(self):
        """kill(eConsoleAppContainer self)"""
        return _enigma.eConsoleAppContainer_kill(self)


    def sendCtrlC(self):
        """sendCtrlC(eConsoleAppContainer self)"""
        return _enigma.eConsoleAppContainer_sendCtrlC(self)


    def sendEOF(self):
        """sendEOF(eConsoleAppContainer self)"""
        return _enigma.eConsoleAppContainer_sendEOF(self)


    def write(self, data, len):
        """write(eConsoleAppContainer self, char const * data, int len)"""
        return _enigma.eConsoleAppContainer_write(self, data, len)


    def setFileFD(self, num, fd):
        """setFileFD(eConsoleAppContainer self, int num, int fd)"""
        return _enigma.eConsoleAppContainer_setFileFD(self, num, fd)


    def running(self):
        """running(eConsoleAppContainer self) -> bool"""
        return _enigma.eConsoleAppContainer_running(self)

    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):
        """__init__(eDict self) -> eDict"""
        _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):
        """__init__(eDictList self) -> eDictList"""
        _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

    def resolve(path):
        """resolve(std::string const & path) -> std::string"""
        return _enigma.eEnv_resolve(path)

    resolve = staticmethod(resolve)

    def __init__(self):
        """__init__(eEnv self) -> eEnv"""
        _enigma.eEnv_swiginit(self, _enigma.new_eEnv())
    __swig_destroy__ = _enigma.delete_eEnv
eEnv_swigregister = _enigma.eEnv_swigregister
eEnv_swigregister(eEnv)

def eEnv_resolve(path):
    """eEnv_resolve(std::string const & path) -> std::string"""
    return _enigma.eEnv_resolve(path)


def segfault():
    return _enigma.segfault()
segfault = _enigma.segfault
NULL = _enigma.NULL

def ptrAssert(p, mangled_type):
    return _enigma.ptrAssert(p, mangled_type)
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)

    def getBeginTime(self):
        """getBeginTime(eServiceEvent self) -> time_t"""
        return _enigma.eServiceEvent_getBeginTime(self)


    def getDuration(self):
        """getDuration(eServiceEvent self) -> int"""
        return _enigma.eServiceEvent_getDuration(self)


    def getEventId(self):
        """getEventId(eServiceEvent self) -> int"""
        return _enigma.eServiceEvent_getEventId(self)


    def getEventName(self):
        """getEventName(eServiceEvent self) -> std::string"""
        return _enigma.eServiceEvent_getEventName(self)


    def getShortDescription(self):
        """getShortDescription(eServiceEvent self) -> std::string"""
        return _enigma.eServiceEvent_getShortDescription(self)


    def getExtendedDescription(self, original=False):
        """
        getExtendedDescription(eServiceEvent self, bool original=False) -> std::string
        getExtendedDescription(eServiceEvent self) -> std::string
        """
        return _enigma.eServiceEvent_getExtendedDescription(self, original)


    def getBeginTimeString(self):
        """getBeginTimeString(eServiceEvent self) -> std::string"""
        return _enigma.eServiceEvent_getBeginTimeString(self)


    def getNumComponent(self):
        """getNumComponent(eServiceEvent self) -> int"""
        return _enigma.eServiceEvent_getNumComponent(self)


    def getComponentData(self, *args):
        """
        getComponentData(eServiceEvent self, int tagnum) -> eComponentData
        getComponentData(eServiceEvent self) -> std::list< std::tuple< int,int,int,std::string,std::string >,std::allocator< std::tuple< int,int,int,std::string,std::string > > >
        """
        return _enigma.eServiceEvent_getComponentData(self, *args)


    def getNumOfLinkageServices(self):
        """getNumOfLinkageServices(eServiceEvent self) -> int"""
        return _enigma.eServiceEvent_getNumOfLinkageServices(self)


    def getLinkageService(self, parent, num):
        """getLinkageService(eServiceEvent self, eServiceReference parent, int num)"""
        return _enigma.eServiceEvent_getLinkageService(self, parent, num)

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(language):
    return _enigma.eServiceEvent_setEPGLanguage(language)
eServiceEvent_setEPGLanguage = _enigma.eServiceEvent_setEPGLanguage

CT_MPEG2 = _enigma.CT_MPEG2
CT_H264 = _enigma.CT_H264
CT_MPEG1 = _enigma.CT_MPEG1
CT_MPEG4_PART2 = _enigma.CT_MPEG4_PART2
CT_VC1 = _enigma.CT_VC1
CT_VC1_SIMPLE_MAIN = _enigma.CT_VC1_SIMPLE_MAIN
CT_H265 = _enigma.CT_H265
CT_DIVX311 = _enigma.CT_DIVX311
CT_DIVX4 = _enigma.CT_DIVX4
CT_SPARK = _enigma.CT_SPARK
CT_VP6 = _enigma.CT_VP6
CT_VP8 = _enigma.CT_VP8
CT_VP9 = _enigma.CT_VP9
CT_H263 = _enigma.CT_H263
CT_MJPEG = _enigma.CT_MJPEG
CT_REAL = _enigma.CT_REAL
CT_AVS = _enigma.CT_AVS
CT_UNKNOWN = _enigma.CT_UNKNOWN
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
    idM2TS = _enigma.eServiceReference_idM2TS
    idDB = _enigma.eServiceReference_idDB
    idUser = _enigma.eServiceReference_idUser
    idGST = _enigma.eServiceReference_idGST
    idDVD = _enigma.eServiceReference_idDVD
    idURI = _enigma.eServiceReference_idURI
    idStream = _enigma.eServiceReference_idStream
    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
    isLive = _enigma.eServiceReference_isLive
    isMulticast = _enigma.eServiceReference_isMulticast
    mustJoinMulticastGroup = _enigma.eServiceReference_mustJoinMulticastGroup
    flags = _swig_property(_enigma.eServiceReference_flags_get, _enigma.eServiceReference_flags_set)

    def getSortKey(self):
        """getSortKey(eServiceReference self) -> int"""
        return _enigma.eServiceReference_getSortKey(self)


    def getPath(self):
        """getPath(eServiceReference self) -> std::string"""
        return _enigma.eServiceReference_getPath(self)


    def setPath(self, n, decode_path=False):
        """
        setPath(eServiceReference self, std::string const & n, bool decode_path=False)
        setPath(eServiceReference self, std::string const & n)
        """
        return _enigma.eServiceReference_setPath(self, n, decode_path)


    def getUnsignedData(self, num):
        """getUnsignedData(eServiceReference self, unsigned int num) -> unsigned int"""
        return _enigma.eServiceReference_getUnsignedData(self, num)


    def getData(self, num):
        """getData(eServiceReference self, unsigned int num) -> int"""
        return _enigma.eServiceReference_getData(self, num)


    def setUnsignedData(self, num, val):
        """setUnsignedData(eServiceReference self, unsigned int num, unsigned int val)"""
        return _enigma.eServiceReference_setUnsignedData(self, num, val)


    def setData(self, num, val):
        """setData(eServiceReference self, unsigned int num, int val)"""
        return _enigma.eServiceReference_setData(self, num, val)


    def getName(self):
        """getName(eServiceReference self) -> std::string"""
        return _enigma.eServiceReference_getName(self)


    def setName(self, n):
        """setName(eServiceReference self, std::string const & n)"""
        return _enigma.eServiceReference_setName(self, n)


    def setUserAgent(self, uA):
        """setUserAgent(eServiceReference self, std::string const & uA)"""
        return _enigma.eServiceReference_setUserAgent(self, uA)


    def getUserAgent(self):
        """getUserAgent(eServiceReference self) -> std::string const"""
        return _enigma.eServiceReference_getUserAgent(self)


    def setTransportHeaders(self, headers):
        """setTransportHeaders(eServiceReference self, StringMap headers)"""
        return _enigma.eServiceReference_setTransportHeaders(self, headers)


    def getTransportHeaders(self):
        """getTransportHeaders(eServiceReference self) -> StringMap"""
        return _enigma.eServiceReference_getTransportHeaders(self)


    def getSuburi(self):
        """getSuburi(eServiceReference self) -> std::string"""
        return _enigma.eServiceReference_getSuburi(self)


    def setSuburi(self, sU):
        """setSuburi(eServiceReference self, std::string const & sU)"""
        return _enigma.eServiceReference_setSuburi(self, sU)


    def __init__(self, *args):
        """
        __init__(eServiceReference self) -> eServiceReference
        __init__(eServiceReference self, int type, int flags, std::string const & p) -> eServiceReference
        __init__(eServiceReference self, std::string const & string) -> eServiceReference
        """
        _enigma.eServiceReference_swiginit(self, _enigma.new_eServiceReference(*args))

    def toString(self):
        """toString(eServiceReference self) -> std::string"""
        return _enigma.eServiceReference_toString(self)


    def toCompareString(self):
        """toCompareString(eServiceReference self) -> std::string"""
        return _enigma.eServiceReference_toCompareString(self)


    def __eq__(self, c):
        """__eq__(eServiceReference self, eServiceReference c) -> bool"""
        return _enigma.eServiceReference___eq__(self, c)


    def __ne__(self, c):
        """__ne__(eServiceReference self, eServiceReference c) -> bool"""
        return _enigma.eServiceReference___ne__(self, c)


    def __lt__(self, c):
        """__lt__(eServiceReference self, eServiceReference c) -> bool"""
        return _enigma.eServiceReference___lt__(self, c)


    def valid(self):
        """valid(eServiceReference self) -> int"""
        return _enigma.eServiceReference_valid(self)


    def compare(self, ref):
        """compare(eServiceReference self, eServiceReference ref) -> int"""
        return _enigma.eServiceReference_compare(self, ref)


    def hash(self):
        """hash(eServiceReference self) -> long"""
        return _enigma.eServiceReference_hash(self)

    __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.setUserAgent = new_instancemethod(_enigma.eServiceReference_setUserAgent, None, eServiceReference)
eServiceReference.getUserAgent = new_instancemethod(_enigma.eServiceReference_getUserAgent, None, eServiceReference)
eServiceReference.setTransportHeaders = new_instancemethod(_enigma.eServiceReference_setTransportHeaders, None, eServiceReference)
eServiceReference.getTransportHeaders = new_instancemethod(_enigma.eServiceReference_getTransportHeaders, None, eServiceReference)
eServiceReference.getSuburi = new_instancemethod(_enigma.eServiceReference_getSuburi, None, eServiceReference)
eServiceReference.setSuburi = new_instancemethod(_enigma.eServiceReference_setSuburi, 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(ref):
    return _enigma.New_eServiceReference(ref)
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

    def getName(self, ref):
        """getName(iStaticServiceInformationPtr self, eServiceReference ref)"""
        return _enigma.iStaticServiceInformationPtr_getName(self, ref)


    def getLength(self, ref):
        """getLength(iStaticServiceInformationPtr self, eServiceReference ref) -> int"""
        return _enigma.iStaticServiceInformationPtr_getLength(self, ref)


    def getLength64(self, ref):
        """getLength64(iStaticServiceInformationPtr self, eServiceReference ref) -> int64_t"""
        return _enigma.iStaticServiceInformationPtr_getLength64(self, ref)


    def getEvent(self, ref, start_time=-1):
        """
        getEvent(iStaticServiceInformationPtr self, eServiceReference ref, time_t start_time=-1)
        getEvent(iStaticServiceInformationPtr self, eServiceReference ref)
        """
        return _enigma.iStaticServiceInformationPtr_getEvent(self, ref, start_time)


    def isPlayable(self, ref, ignore, simulate=False):
        """
        isPlayable(iStaticServiceInformationPtr self, eServiceReference ref, eServiceReference ignore, bool simulate=False) -> int
        isPlayable(iStaticServiceInformationPtr self, eServiceReference ref, eServiceReference ignore) -> int
        """
        return _enigma.iStaticServiceInformationPtr_isPlayable(self, ref, ignore, simulate)


    def getInfo(self, ref, w):
        """getInfo(iStaticServiceInformationPtr self, eServiceReference ref, int w) -> int"""
        return _enigma.iStaticServiceInformationPtr_getInfo(self, ref, w)


    def getInfoString(self, ref, w):
        """getInfoString(iStaticServiceInformationPtr self, eServiceReference ref, int w) -> std::string"""
        return _enigma.iStaticServiceInformationPtr_getInfoString(self, ref, w)


    def getInfoObject(self, ref, w):
        """getInfoObject(iStaticServiceInformationPtr self, eServiceReference ref, int w) -> boost::any"""
        return _enigma.iStaticServiceInformationPtr_getInfoObject(self, ref, w)


    def setInfo(self, ref, w, v):
        """setInfo(iStaticServiceInformationPtr self, eServiceReference ref, int w, int v) -> int"""
        return _enigma.iStaticServiceInformationPtr_setInfo(self, ref, w, v)


    def setInfoString(self, ref, w, v):
        """setInfoString(iStaticServiceInformationPtr self, eServiceReference ref, int w, char const * v) -> int"""
        return _enigma.iStaticServiceInformationPtr_setInfoString(self, ref, w, v)

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.getLength64 = new_instancemethod(_enigma.iStaticServiceInformationPtr_getLength64, 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
    sEotf = _enigma.iServiceInformation_ENUMS_sEotf
    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
    sAudioType = _enigma.iServiceInformation_ENUMS_sAudioType
    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
    sAngle = _enigma.iServiceInformation_ENUMS_sAngle
    sUser = _enigma.iServiceInformation_ENUMS_sUser
    sErrorText = _enigma.iServiceInformation_ENUMS_sErrorText
    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

    def getName(self):
        """getName(iServiceInformationPtr self)"""
        return _enigma.iServiceInformationPtr_getName(self)


    def getEvent(self, nownext):
        """getEvent(iServiceInformationPtr self, int nownext)"""
        return _enigma.iServiceInformationPtr_getEvent(self, nownext)


    def getInfo(self, w):
        """getInfo(iServiceInformationPtr self, int w) -> int"""
        return _enigma.iServiceInformationPtr_getInfo(self, w)


    def getInfoString(self, w):
        """getInfoString(iServiceInformationPtr self, int w) -> std::string"""
        return _enigma.iServiceInformationPtr_getInfoString(self, w)


    def getInfoObject(self, w):
        """getInfoObject(iServiceInformationPtr self, int w) -> boost::any"""
        return _enigma.iServiceInformationPtr_getInfoObject(self, w)


    def setInfo(self, w, v):
        """setInfo(iServiceInformationPtr self, int w, int v) -> int"""
        return _enigma.iServiceInformationPtr_setInfo(self, w, v)


    def setInfoString(self, w, v):
        """setInfoString(iServiceInformationPtr self, int w, char const * v) -> int"""
        return _enigma.iServiceInformationPtr_setInfoString(self, w, v)

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
    uncorrBlocks = _enigma.iFrontendInformation_ENUMS_uncorrBlocks
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

    def getFrontendInfo(self, w):
        """getFrontendInfo(iFrontendInformationPtr self, int w) -> int"""
        return _enigma.iFrontendInformationPtr_getFrontendInfo(self, w)


    def getFrontendData(self):
        """getFrontendData(iFrontendInformationPtr self)"""
        return _enigma.iFrontendInformationPtr_getFrontendData(self)


    def getFrontendStatus(self):
        """getFrontendStatus(iFrontendInformationPtr self)"""
        return _enigma.iFrontendInformationPtr_getFrontendStatus(self)


    def getTransponderData(self, original):
        """getTransponderData(iFrontendInformationPtr self, bool original)"""
        return _enigma.iFrontendInformationPtr_getTransponderData(self, original)


    def getAll(self, original):
        """getAll(iFrontendInformationPtr self, bool original)"""
        return _enigma.iFrontendInformationPtr_getAll(self, original)

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

    def pause(self):
        """pause(iPauseableServicePtr self) -> RESULT"""
        return _enigma.iPauseableServicePtr_pause(self)


    def unpause(self):
        """unpause(iPauseableServicePtr self) -> RESULT"""
        return _enigma.iPauseableServicePtr_unpause(self)


    def setSlowMotion(self, ratio=0):
        """
        setSlowMotion(iPauseableServicePtr self, int ratio=0) -> RESULT
        setSlowMotion(iPauseableServicePtr self) -> RESULT
        """
        return _enigma.iPauseableServicePtr_setSlowMotion(self, ratio)


    def setFastForward(self, ratio=0):
        """
        setFastForward(iPauseableServicePtr self, int ratio=0) -> RESULT
        setFastForward(iPauseableServicePtr self) -> RESULT
        """
        return _enigma.iPauseableServicePtr_setFastForward(self, ratio)

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

    def getLength(self):
        """getLength(iSeekableServicePtr self) -> RESULT"""
        return _enigma.iSeekableServicePtr_getLength(self)


    def seekTo(self, to):
        """seekTo(iSeekableServicePtr self, pts_t to) -> RESULT"""
        return _enigma.iSeekableServicePtr_seekTo(self, to)


    def seekRelative(self, direction, to):
        """seekRelative(iSeekableServicePtr self, int direction, pts_t to) -> RESULT"""
        return _enigma.iSeekableServicePtr_seekRelative(self, direction, to)


    def getPlayPosition(self):
        """getPlayPosition(iSeekableServicePtr self) -> RESULT"""
        return _enigma.iSeekableServicePtr_getPlayPosition(self)


    def setTrickmode(self, trick=0):
        """
        setTrickmode(iSeekableServicePtr self, int trick=0) -> RESULT
        setTrickmode(iSeekableServicePtr self) -> RESULT
        """
        return _enigma.iSeekableServicePtr_setTrickmode(self, trick)


    def isCurrentlySeekable(self):
        """isCurrentlySeekable(iSeekableServicePtr self) -> RESULT"""
        return _enigma.iSeekableServicePtr_isCurrentlySeekable(self)


    def seekChapter(self, arg2):
        """seekChapter(iSeekableServicePtr self, int arg2) -> RESULT"""
        return _enigma.iSeekableServicePtr_seekChapter(self, arg2)


    def seekTitle(self, arg2):
        """seekTitle(iSeekableServicePtr self, int arg2) -> RESULT"""
        return _enigma.iSeekableServicePtr_seekTitle(self, arg2)

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 iAudioType_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
    atMPEG = _enigma.iAudioType_ENUMS_atMPEG
    atAC3 = _enigma.iAudioType_ENUMS_atAC3
    atDTS = _enigma.iAudioType_ENUMS_atDTS
    atAAC = _enigma.iAudioType_ENUMS_atAAC
    atAACHE = _enigma.iAudioType_ENUMS_atAACHE
    atLPCM = _enigma.iAudioType_ENUMS_atLPCM
    atDTSHD = _enigma.iAudioType_ENUMS_atDTSHD
    atDDP = _enigma.iAudioType_ENUMS_atDDP
    atMP3 = _enigma.iAudioType_ENUMS_atMP3
    atPCM = _enigma.iAudioType_ENUMS_atPCM
    atOGG = _enigma.iAudioType_ENUMS_atOGG
    atFLAC = _enigma.iAudioType_ENUMS_atFLAC
    atWMA = _enigma.iAudioType_ENUMS_atWMA
    atTRUEHD = _enigma.iAudioType_ENUMS_atTRUEHD
    atUnknown = _enigma.iAudioType_ENUMS_atUnknown
iAudioType_ENUMS_swigregister = _enigma.iAudioType_ENUMS_swigregister
iAudioType_ENUMS_swigregister(iAudioType_ENUMS)

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

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

    def getDescription(self):
        """getDescription(iAudioTrackInfo self) -> std::string"""
        return _enigma.iAudioTrackInfo_getDescription(self)


    def getLanguage(self):
        """getLanguage(iAudioTrackInfo self) -> std::string"""
        return _enigma.iAudioTrackInfo_getLanguage(self)


    def getPID(self):
        """getPID(iAudioTrackInfo self) -> int"""
        return _enigma.iAudioTrackInfo_getPID(self)


    def getType(self):
        """getType(iAudioTrackInfo self) -> int"""
        return _enigma.iAudioTrackInfo_getType(self)


    def isSaved(self):
        """isSaved(iAudioTrackInfo self) -> int"""
        return _enigma.iAudioTrackInfo_isSaved(self)


    def isDefault(self):
        """isDefault(iAudioTrackInfo self) -> int"""
        return _enigma.iAudioTrackInfo_isDefault(self)


    def setLanguage(self, language):
        """setLanguage(iAudioTrackInfo self, std::string language)"""
        return _enigma.iAudioTrackInfo_setLanguage(self, language)


    def setDescription(self, description):
        """setDescription(iAudioTrackInfo self, std::string description)"""
        return _enigma.iAudioTrackInfo_setDescription(self, description)

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.getType = new_instancemethod(_enigma.iAudioTrackInfo_getType, None, iAudioTrackInfo)
iAudioTrackInfo.isSaved = new_instancemethod(_enigma.iAudioTrackInfo_isSaved, None, iAudioTrackInfo)
iAudioTrackInfo.isDefault = new_instancemethod(_enigma.iAudioTrackInfo_isDefault, None, iAudioTrackInfo)
iAudioTrackInfo.setLanguage = new_instancemethod(_enigma.iAudioTrackInfo_setLanguage, None, iAudioTrackInfo)
iAudioTrackInfo.setDescription = new_instancemethod(_enigma.iAudioTrackInfo_setDescription, 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

    def getNumberOfTracks(self):
        """getNumberOfTracks(iAudioTrackSelectionPtr self) -> int"""
        return _enigma.iAudioTrackSelectionPtr_getNumberOfTracks(self)


    def selectTrack(self, i):
        """selectTrack(iAudioTrackSelectionPtr self, unsigned int i) -> RESULT"""
        return _enigma.iAudioTrackSelectionPtr_selectTrack(self, i)


    def getTrackInfo(self, n):
        """getTrackInfo(iAudioTrackSelectionPtr self, unsigned int n)"""
        return _enigma.iAudioTrackSelectionPtr_getTrackInfo(self, n)


    def getCurrentTrack(self):
        """getCurrentTrack(iAudioTrackSelectionPtr self) -> int"""
        return _enigma.iAudioTrackSelectionPtr_getCurrentTrack(self)

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

    def getCurrentChannel(self):
        """getCurrentChannel(iAudioChannelSelectionPtr self) -> int"""
        return _enigma.iAudioChannelSelectionPtr_getCurrentChannel(self)


    def selectChannel(self, i):
        """selectChannel(iAudioChannelSelectionPtr self, int i) -> RESULT"""
        return _enigma.iAudioChannelSelectionPtr_selectChannel(self, i)

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

    def getAC3Delay(self):
        """getAC3Delay(iAudioDelayPtr self) -> int"""
        return _enigma.iAudioDelayPtr_getAC3Delay(self)


    def getPCMDelay(self):
        """getPCMDelay(iAudioDelayPtr self) -> int"""
        return _enigma.iAudioDelayPtr_getPCMDelay(self)


    def setAC3Delay(self, arg2):
        """setAC3Delay(iAudioDelayPtr self, int arg2)"""
        return _enigma.iAudioDelayPtr_setAC3Delay(self, arg2)


    def setPCMDelay(self, arg2):
        """setPCMDelay(iAudioDelayPtr self, int arg2)"""
        return _enigma.iAudioDelayPtr_setPCMDelay(self, arg2)

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

    def getText(self, *args):
        """
        getText(iRdsDecoderPtr self, int x) -> std::string
        getText(iRdsDecoderPtr self) -> std::string
        """
        return _enigma.iRdsDecoderPtr_getText(self, *args)


    def showRassSlidePicture(self):
        """showRassSlidePicture(iRdsDecoderPtr self)"""
        return _enigma.iRdsDecoderPtr_showRassSlidePicture(self)


    def showRassInteractivePic(self, page, subpage):
        """showRassInteractivePic(iRdsDecoderPtr self, int page, int subpage)"""
        return _enigma.iRdsDecoderPtr_showRassInteractivePic(self, page, subpage)


    def getRassInteractiveMask(self):
        """getRassInteractiveMask(iRdsDecoderPtr self) -> unsigned char const *"""
        return _enigma.iRdsDecoderPtr_getRassInteractiveMask(self)

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

    def getNumberOfSubservices(self):
        """getNumberOfSubservices(iSubserviceListPtr self) -> int"""
        return _enigma.iSubserviceListPtr_getNumberOfSubservices(self)


    def getSubservice(self, n):
        """getSubservice(iSubserviceListPtr self, unsigned int n)"""
        return _enigma.iSubserviceListPtr_getSubservice(self, n)

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

    def startTimeshift(self):
        """startTimeshift(iTimeshiftServicePtr self) -> RESULT"""
        return _enigma.iTimeshiftServicePtr_startTimeshift(self)


    def stopTimeshift(self, mode=1):
        """
        stopTimeshift(iTimeshiftServicePtr self, int mode=1) -> RESULT
        stopTimeshift(iTimeshiftServicePtr self) -> RESULT
        """
        return _enigma.iTimeshiftServicePtr_stopTimeshift(self, mode)


    def setNextPlaybackFile(self, fn):
        """setNextPlaybackFile(iTimeshiftServicePtr self, char const * fn) -> RESULT"""
        return _enigma.iTimeshiftServicePtr_setNextPlaybackFile(self, fn)


    def setPrevPlaybackFile(self, fn):
        """setPrevPlaybackFile(iTimeshiftServicePtr self, char const * fn) -> RESULT"""
        return _enigma.iTimeshiftServicePtr_setPrevPlaybackFile(self, fn)


    def isTimeshiftActive(self):
        """isTimeshiftActive(iTimeshiftServicePtr self) -> int"""
        return _enigma.iTimeshiftServicePtr_isTimeshiftActive(self)


    def activateTimeshift(self):
        """activateTimeshift(iTimeshiftServicePtr self) -> RESULT"""
        return _enigma.iTimeshiftServicePtr_activateTimeshift(self)

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.setPrevPlaybackFile = new_instancemethod(_enigma.iTimeshiftServicePtr_setPrevPlaybackFile, 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

    def getCutList(self):
        """getCutList(iCueSheetPtr self) -> std::list< std::pair< pts_t,unsigned int >,std::allocator< std::pair< pts_t,unsigned int > > >"""
        return _enigma.iCueSheetPtr_getCutList(self)


    def setCutList(self, list):
        """setCutList(iCueSheetPtr self, std::list< std::pair< pts_t,unsigned int >,std::allocator< std::pair< pts_t,unsigned int > > > list)"""
        return _enigma.iCueSheetPtr_setCutList(self, list)


    def setCutListEnable(self, enable):
        """setCutListEnable(iCueSheetPtr self, int enable)"""
        return _enigma.iCueSheetPtr_setCutListEnable(self, enable)

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 iSubtitleType_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
    NONE = _enigma.iSubtitleType_ENUMS_NONE
    DVB = _enigma.iSubtitleType_ENUMS_DVB
    TTX = _enigma.iSubtitleType_ENUMS_TTX
    DVD = _enigma.iSubtitleType_ENUMS_DVD
    GST = _enigma.iSubtitleType_ENUMS_GST
    TXT = _enigma.iSubtitleType_ENUMS_TXT
iSubtitleType_ENUMS_swigregister = _enigma.iSubtitleType_ENUMS_swigregister
iSubtitleType_ENUMS_swigregister(iSubtitleType_ENUMS)

class iGstSubtitleType_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
    stUnknown = _enigma.iGstSubtitleType_ENUMS_stUnknown
    stPlainText = _enigma.iGstSubtitleType_ENUMS_stPlainText
    stSSA = _enigma.iGstSubtitleType_ENUMS_stSSA
    stASS = _enigma.iGstSubtitleType_ENUMS_stASS
    stVOB = _enigma.iGstSubtitleType_ENUMS_stVOB
    stPGS = _enigma.iGstSubtitleType_ENUMS_stPGS
iGstSubtitleType_ENUMS_swigregister = _enigma.iGstSubtitleType_ENUMS_swigregister
iGstSubtitleType_ENUMS_swigregister(iGstSubtitleType_ENUMS)

class iSubtitleFilterType_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
    SUB_FILTER_NONE = _enigma.iSubtitleFilterType_ENUMS_SUB_FILTER_NONE
    SUB_FILTER_SHOW_FORCED_ONLY = _enigma.iSubtitleFilterType_ENUMS_SUB_FILTER_SHOW_FORCED_ONLY
    SUB_FILTER_SHOW_ALL = _enigma.iSubtitleFilterType_ENUMS_SUB_FILTER_SHOW_ALL
iSubtitleFilterType_ENUMS_swigregister = _enigma.iSubtitleFilterType_ENUMS_swigregister
iSubtitleFilterType_ENUMS_swigregister(iSubtitleFilterType_ENUMS)

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

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

    def getType(self):
        """getType(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_getType(self)


    def getPID(self):
        """getPID(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_getPID(self)


    def getLanguage(self):
        """getLanguage(iSubtitleTrackInfo self) -> std::string"""
        return _enigma.iSubtitleTrackInfo_getLanguage(self)


    def getCompositionPageID(self):
        """getCompositionPageID(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_getCompositionPageID(self)


    def getAncillaryPageID(self):
        """getAncillaryPageID(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_getAncillaryPageID(self)


    def getPageNumber(self):
        """getPageNumber(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_getPageNumber(self)


    def getMagazineNumber(self):
        """getMagazineNumber(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_getMagazineNumber(self)


    def getGstSubtype(self):
        """getGstSubtype(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_getGstSubtype(self)


    def isSaved(self):
        """isSaved(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_isSaved(self)


    def isDefault(self):
        """isDefault(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_isDefault(self)


    def isForced(self):
        """isForced(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_isForced(self)


    def getFilter(self):
        """getFilter(iSubtitleTrackInfo self) -> int"""
        return _enigma.iSubtitleTrackInfo_getFilter(self)


    def setLanguage(self, language):
        """setLanguage(iSubtitleTrackInfo self, std::string language)"""
        return _enigma.iSubtitleTrackInfo_setLanguage(self, language)


    def setFilter(self, filter):
        """setFilter(iSubtitleTrackInfo self, int filter)"""
        return _enigma.iSubtitleTrackInfo_setFilter(self, filter)


    def setGstSubtype(self, gst_subtype):
        """setGstSubtype(iSubtitleTrackInfo self, int gst_subtype)"""
        return _enigma.iSubtitleTrackInfo_setGstSubtype(self, gst_subtype)

iSubtitleTrackInfo.getType = new_instancemethod(_enigma.iSubtitleTrackInfo_getType, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.getPID = new_instancemethod(_enigma.iSubtitleTrackInfo_getPID, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.getLanguage = new_instancemethod(_enigma.iSubtitleTrackInfo_getLanguage, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.getCompositionPageID = new_instancemethod(_enigma.iSubtitleTrackInfo_getCompositionPageID, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.getAncillaryPageID = new_instancemethod(_enigma.iSubtitleTrackInfo_getAncillaryPageID, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.getPageNumber = new_instancemethod(_enigma.iSubtitleTrackInfo_getPageNumber, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.getMagazineNumber = new_instancemethod(_enigma.iSubtitleTrackInfo_getMagazineNumber, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.getGstSubtype = new_instancemethod(_enigma.iSubtitleTrackInfo_getGstSubtype, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.isSaved = new_instancemethod(_enigma.iSubtitleTrackInfo_isSaved, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.isDefault = new_instancemethod(_enigma.iSubtitleTrackInfo_isDefault, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.isForced = new_instancemethod(_enigma.iSubtitleTrackInfo_isForced, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.getFilter = new_instancemethod(_enigma.iSubtitleTrackInfo_getFilter, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.setLanguage = new_instancemethod(_enigma.iSubtitleTrackInfo_setLanguage, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.setFilter = new_instancemethod(_enigma.iSubtitleTrackInfo_setFilter, None, iSubtitleTrackInfo)
iSubtitleTrackInfo.setGstSubtype = new_instancemethod(_enigma.iSubtitleTrackInfo_setGstSubtype, None, iSubtitleTrackInfo)
iSubtitleTrackInfo_swigregister = _enigma.iSubtitleTrackInfo_swigregister
iSubtitleTrackInfo_swigregister(iSubtitleTrackInfo)

class iSubtitleTrackSelectionPtr(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.iSubtitleTrackSelectionPtr_swiginit(self, _enigma.new_iSubtitleTrackSelectionPtr(*args))
    __swig_destroy__ = _enigma.delete_iSubtitleTrackSelectionPtr

    def getNumberOfSubtitleTracks(self):
        """getNumberOfSubtitleTracks(iSubtitleTrackSelectionPtr self) -> int"""
        return _enigma.iSubtitleTrackSelectionPtr_getNumberOfSubtitleTracks(self)


    def getSubtitleTrackInfo(self, n):
        """getSubtitleTrackInfo(iSubtitleTrackSelectionPtr self, unsigned int n)"""
        return _enigma.iSubtitleTrackSelectionPtr_getSubtitleTrackInfo(self, n)


    def getCurrentSubtitleTrack(self):
        """getCurrentSubtitleTrack(iSubtitleTrackSelectionPtr self) -> int"""
        return _enigma.iSubtitleTrackSelectionPtr_getCurrentSubtitleTrack(self)


    def enableSubtitles(self, parent, i):
        """enableSubtitles(iSubtitleTrackSelectionPtr self, eWidget parent, unsigned int i) -> RESULT"""
        return _enigma.iSubtitleTrackSelectionPtr_enableSubtitles(self, parent, i)


    def disableSubtitles(self, parent):
        """disableSubtitles(iSubtitleTrackSelectionPtr self, eWidget parent) -> RESULT"""
        return _enigma.iSubtitleTrackSelectionPtr_disableSubtitles(self, parent)

iSubtitleTrackSelectionPtr.__ref__ = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr___ref__, None, iSubtitleTrackSelectionPtr)
iSubtitleTrackSelectionPtr.getPtrString = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_getPtrString, None, iSubtitleTrackSelectionPtr)
iSubtitleTrackSelectionPtr.__deref__ = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr___deref__, None, iSubtitleTrackSelectionPtr)
iSubtitleTrackSelectionPtr.getNumberOfSubtitleTracks = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_getNumberOfSubtitleTracks, None, iSubtitleTrackSelectionPtr)
iSubtitleTrackSelectionPtr.getSubtitleTrackInfo = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_getSubtitleTrackInfo, None, iSubtitleTrackSelectionPtr)
iSubtitleTrackSelectionPtr.getCurrentSubtitleTrack = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_getCurrentSubtitleTrack, None, iSubtitleTrackSelectionPtr)
iSubtitleTrackSelectionPtr.enableSubtitles = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_enableSubtitles, None, iSubtitleTrackSelectionPtr)
iSubtitleTrackSelectionPtr.disableSubtitles = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_disableSubtitles, None, iSubtitleTrackSelectionPtr)
iSubtitleTrackSelectionPtr_swigregister = _enigma.iSubtitleTrackSelectionPtr_swigregister
iSubtitleTrackSelectionPtr_swigregister(iSubtitleTrackSelectionPtr)

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

    def flushChanges(self):
        """flushChanges(iMutableServiceListPtr self) -> RESULT"""
        return _enigma.iMutableServiceListPtr_flushChanges(self)


    def addService(self, *args):
        """
        addService(iMutableServiceListPtr self, eServiceReference ref, eServiceReference before) -> RESULT
        addService(iMutableServiceListPtr self, eServiceReference ref) -> RESULT
        """
        return _enigma.iMutableServiceListPtr_addService(self, *args)


    def removeService(self, ref):
        """removeService(iMutableServiceListPtr self, eServiceReference ref) -> RESULT"""
        return _enigma.iMutableServiceListPtr_removeService(self, ref)


    def moveService(self, ref, pos):
        """moveService(iMutableServiceListPtr self, eServiceReference ref, int pos) -> RESULT"""
        return _enigma.iMutableServiceListPtr_moveService(self, ref, pos)


    def setListName(self, name):
        """setListName(iMutableServiceListPtr self, std::string const & name) -> RESULT"""
        return _enigma.iMutableServiceListPtr_setListName(self, name)

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

    def getContent(self, format, sorted=False):
        """
        getContent(iListableServicePtr self, char const * format, bool sorted=False) -> PyObject
        getContent(iListableServicePtr self, char const * format) -> PyObject *
        """
        return _enigma.iListableServicePtr_getContent(self, format, sorted)


    def getNext(self):
        """getNext(iListableServicePtr self)"""
        return _enigma.iListableServicePtr_getNext(self)


    def compareLessEqual(self, arg2, arg3):
        """compareLessEqual(iListableServicePtr self, eServiceReference arg2, eServiceReference arg3) -> int"""
        return _enigma.iListableServicePtr_compareLessEqual(self, arg2, arg3)


    def startEdit(self):
        """startEdit(iListableServicePtr self)"""
        return _enigma.iListableServicePtr_startEdit(self)

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

    def deleteFromDisk(self, simulate=1):
        """
        deleteFromDisk(iServiceOfflineOperationsPtr self, int simulate=1) -> RESULT
        deleteFromDisk(iServiceOfflineOperationsPtr self) -> RESULT
        """
        return _enigma.iServiceOfflineOperationsPtr_deleteFromDisk(self, simulate)


    def getListOfFilenames(self, OUTPUT):
        """getListOfFilenames(iServiceOfflineOperationsPtr self, StringList OUTPUT)"""
        return _enigma.iServiceOfflineOperationsPtr_getListOfFilenames(self, OUTPUT)


    def reindex(self):
        """reindex(iServiceOfflineOperationsPtr self) -> int"""
        return _enigma.iServiceOfflineOperationsPtr_reindex(self)

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

    def getStreamingData(self, includeEit=True):
        """
        getStreamingData(iStreamableServicePtr self, bool includeEit=True) -> PseudoDict
        getStreamingData(iStreamableServicePtr self) -> PseudoDict
        """
        return _enigma.iStreamableServicePtr_getStreamingData(self, includeEit)

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

    def getBufferCharge(self):
        """getBufferCharge(iStreamedServicePtr self) -> IntList"""
        return _enigma.iStreamedServicePtr_getBufferCharge(self)


    def setBufferSize(self, size):
        """setBufferSize(iStreamedServicePtr self, int size) -> int"""
        return _enigma.iStreamedServicePtr_setBufferSize(self, size)


    def setBufferDuration(self, ms):
        """setBufferDuration(iStreamedServicePtr self, int ms) -> int"""
        return _enigma.iStreamedServicePtr_setBufferDuration(self, ms)


    def setTransportHeaders(self, headers):
        """setTransportHeaders(iStreamedServicePtr self, StringMap headers)"""
        return _enigma.iStreamedServicePtr_setTransportHeaders(self, headers)

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.setBufferDuration = new_instancemethod(_enigma.iStreamedServicePtr_setBufferDuration, None, iStreamedServicePtr)
iStreamedServicePtr.setTransportHeaders = new_instancemethod(_enigma.iStreamedServicePtr_setTransportHeaders, None, iStreamedServicePtr)
iStreamedServicePtr_swigregister = _enigma.iStreamedServicePtr_swigregister
iStreamedServicePtr_swigregister(iStreamedServicePtr)

class iUriService(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 setResolvedName(self, name):
        """setResolvedName(iUriService self, std::string const & name)"""
        return _enigma.iUriService_setResolvedName(self, name)


    def setResolvedUri(self, *args):
        """
        setResolvedUri(iUriService self, std::string const & resolvedUri, int serviceType, std::string const & suburi)
        setResolvedUri(iUriService self, std::string const & resolvedUri, int serviceType)
        """
        return _enigma.iUriService_setResolvedUri(self, *args)


    def failedToResolveUri(self):
        """failedToResolveUri(iUriService self)"""
        return _enigma.iUriService_failedToResolveUri(self)

iUriService.setResolvedName = new_instancemethod(_enigma.iUriService_setResolvedName, None, iUriService)
iUriService.setResolvedUri = new_instancemethod(_enigma.iUriService_setResolvedUri, None, iUriService)
iUriService.failedToResolveUri = new_instancemethod(_enigma.iUriService_failedToResolveUri, None, iUriService)
iUriService_swigregister = _enigma.iUriService_swigregister
iUriService_swigregister(iUriService)

class iUriServicePtr(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.iUriServicePtr_swiginit(self, _enigma.new_iUriServicePtr(*args))
    __swig_destroy__ = _enigma.delete_iUriServicePtr

    def setResolvedName(self, name):
        """setResolvedName(iUriServicePtr self, std::string const & name)"""
        return _enigma.iUriServicePtr_setResolvedName(self, name)


    def setResolvedUri(self, *args):
        """
        setResolvedUri(iUriServicePtr self, std::string const & resolvedUri, int serviceType, std::string const & suburi)
        setResolvedUri(iUriServicePtr self, std::string const & resolvedUri, int serviceType)
        """
        return _enigma.iUriServicePtr_setResolvedUri(self, *args)


    def failedToResolveUri(self):
        """failedToResolveUri(iUriServicePtr self)"""
        return _enigma.iUriServicePtr_failedToResolveUri(self)

iUriServicePtr.__ref__ = new_instancemethod(_enigma.iUriServicePtr___ref__, None, iUriServicePtr)
iUriServicePtr.getPtrString = new_instancemethod(_enigma.iUriServicePtr_getPtrString, None, iUriServicePtr)
iUriServicePtr.__deref__ = new_instancemethod(_enigma.iUriServicePtr___deref__, None, iUriServicePtr)
iUriServicePtr.setResolvedName = new_instancemethod(_enigma.iUriServicePtr_setResolvedName, None, iUriServicePtr)
iUriServicePtr.setResolvedUri = new_instancemethod(_enigma.iUriServicePtr_setResolvedUri, None, iUriServicePtr)
iUriServicePtr.failedToResolveUri = new_instancemethod(_enigma.iUriServicePtr_failedToResolveUri, None, iUriServicePtr)
iUriServicePtr_swigregister = _enigma.iUriServicePtr_swigregister
iUriServicePtr_swigregister(iUriServicePtr)

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

    def keyPressed(self, key):
        """keyPressed(iServiceKeysPtr self, int key)"""
        return _enigma.iServiceKeysPtr_keyPressed(self, key)

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
    evVideoTypeReady = _enigma.iPlayableService_ENUMS_evVideoTypeReady
    evVideoSizeChanged = _enigma.iPlayableService_ENUMS_evVideoSizeChanged
    evVideoFramerateChanged = _enigma.iPlayableService_ENUMS_evVideoFramerateChanged
    evVideoProgressiveChanged = _enigma.iPlayableService_ENUMS_evVideoProgressiveChanged
    evVideoPtsValid = _enigma.iPlayableService_ENUMS_evVideoPtsValid
    evBuffering = _enigma.iPlayableService_ENUMS_evBuffering
    evStopped = _enigma.iPlayableService_ENUMS_evStopped
    evSubtitleListChanged = _enigma.iPlayableService_ENUMS_evSubtitleListChanged
    evAudioListChanged = _enigma.iPlayableService_ENUMS_evAudioListChanged
    evPause = _enigma.iPlayableService_ENUMS_evPause
    evPlay = _enigma.iPlayableService_ENUMS_evPlay
    evSeek = _enigma.iPlayableService_ENUMS_evSeek
    evNotFound = _enigma.iPlayableService_ENUMS_evNotFound
    evServiceChanged = _enigma.iPlayableService_ENUMS_evServiceChanged
    evUser = _enigma.iPlayableService_ENUMS_evUser
    stateIdle = _enigma.iPlayableService_ENUMS_stateIdle
    stateStop = _enigma.iPlayableService_ENUMS_stateStop
    statePlay = _enigma.iPlayableService_ENUMS_statePlay
    statePause = _enigma.iPlayableService_ENUMS_statePause
    stateBuffering = _enigma.iPlayableService_ENUMS_stateBuffering
    stateSeek = _enigma.iPlayableService_ENUMS_stateSeek
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

    def start(self):
        """start(iPlayableServicePtr self) -> RESULT"""
        return _enigma.iPlayableServicePtr_start(self)


    def stop(self):
        """stop(iPlayableServicePtr self) -> RESULT"""
        return _enigma.iPlayableServicePtr_stop(self)


    def playState(self):
        """playState(iPlayableServicePtr self) -> int"""
        return _enigma.iPlayableServicePtr_playState(self)


    def setTarget(self, target):
        """setTarget(iPlayableServicePtr self, int target) -> RESULT"""
        return _enigma.iPlayableServicePtr_setTarget(self, target)


    def seek(self):
        """seek(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_seek(self)


    def pause(self):
        """pause(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_pause(self)


    def info(self):
        """info(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_info(self)


    def audioTracks(self):
        """audioTracks(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_audioTracks(self)


    def audioChannel(self):
        """audioChannel(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_audioChannel(self)


    def subServices(self):
        """subServices(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_subServices(self)


    def frontendInfo(self):
        """frontendInfo(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_frontendInfo(self)


    def timeshift(self):
        """timeshift(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_timeshift(self)


    def cueSheet(self):
        """cueSheet(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_cueSheet(self)


    def subtitleTracks(self):
        """subtitleTracks(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_subtitleTracks(self)


    def audioDelay(self):
        """audioDelay(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_audioDelay(self)


    def rdsDecoder(self):
        """rdsDecoder(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_rdsDecoder(self)


    def stream(self):
        """stream(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_stream(self)


    def streamed(self):
        """streamed(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_streamed(self)


    def keys(self):
        """keys(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_keys(self)


    def hbbtv(self):
        """hbbtv(iPlayableServicePtr self)"""
        return _enigma.iPlayableServicePtr_hbbtv(self)

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.playState = new_instancemethod(_enigma.iPlayableServicePtr_playState, 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.subtitleTracks = new_instancemethod(_enigma.iPlayableServicePtr_subtitleTracks, 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
    evGstRecordEOS = _enigma.iRecordableService_ENUMS_evGstRecordEOS
    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

    def getError(self):
        """getError(iRecordableServicePtr self)"""
        return _enigma.iRecordableServicePtr_getError(self)


    def prepare(self, filename, begTime=-1, endTime=-1, eit_event_id=-1, name=None, descr=None, tags=None):
        """
        prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1, char const * name=None, char const * descr=None, char const * tags=None) -> RESULT
        prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1, char const * name=None, char const * descr=None) -> RESULT
        prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1, char const * name=None) -> RESULT
        prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1) -> RESULT
        prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1, time_t endTime=-1) -> RESULT
        prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1) -> RESULT
        prepare(iRecordableServicePtr self, char const * filename) -> RESULT
        """
        return _enigma.iRecordableServicePtr_prepare(self, filename, begTime, endTime, eit_event_id, name, descr, tags)


    def prepareStreaming(self):
        """prepareStreaming(iRecordableServicePtr self) -> RESULT"""
        return _enigma.iRecordableServicePtr_prepareStreaming(self)


    def start(self, simulate=False):
        """
        start(iRecordableServicePtr self, bool simulate=False) -> RESULT
        start(iRecordableServicePtr self) -> RESULT
        """
        return _enigma.iRecordableServicePtr_start(self, simulate)


    def stop(self):
        """stop(iRecordableServicePtr self) -> RESULT"""
        return _enigma.iRecordableServicePtr_stop(self)


    def frontendInfo(self):
        """frontendInfo(iRecordableServicePtr self)"""
        return _enigma.iRecordableServicePtr_frontendInfo(self)


    def stream(self):
        """stream(iRecordableServicePtr self)"""
        return _enigma.iRecordableServicePtr_stream(self)


    def subServices(self):
        """subServices(iRecordableServicePtr self)"""
        return _enigma.iRecordableServicePtr_subServices(self)


    def getFileExtension(self):
        """getFileExtension(iRecordableServicePtr self)"""
        return _enigma.iRecordableServicePtr_getFileExtension(self)

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.getFileExtension = new_instancemethod(_enigma.iRecordableServicePtr_getFileExtension, None, iRecordableServicePtr)
iRecordableServicePtr_swigregister = _enigma.iRecordableServicePtr_swigregister
iRecordableServicePtr_swigregister(iRecordableServicePtr)


def New_iRecordableServicePtr(ref):
    return _enigma.New_iRecordableServicePtr(ref)
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

    def play(self, arg2):
        """play(iServiceHandlerPtr self, eServiceReference arg2)"""
        return _enigma.iServiceHandlerPtr_play(self, arg2)


    def record(self, arg2):
        """record(iServiceHandlerPtr self, eServiceReference arg2)"""
        return _enigma.iServiceHandlerPtr_record(self, arg2)


    def list(self, arg2):
        """list(iServiceHandlerPtr self, eServiceReference arg2)"""
        return _enigma.iServiceHandlerPtr_list(self, arg2)


    def info(self, arg2):
        """info(iServiceHandlerPtr self, eServiceReference arg2)"""
        return _enigma.iServiceHandlerPtr_info(self, arg2)


    def offlineOperations(self, arg2):
        """offlineOperations(iServiceHandlerPtr self, eServiceReference arg2)"""
        return _enigma.iServiceHandlerPtr_offlineOperations(self, arg2)

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

    def getInstance():
        """getInstance()"""
        return _enigma.eServiceCenter_getInstance()

    getInstance = staticmethod(getInstance)
eServiceCenter_swigregister = _enigma.eServiceCenter_swigregister
eServiceCenter_swigregister(eServiceCenter)

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

HTTP_TIMEOUT = _enigma.HTTP_TIMEOUT
class eGstMsgContainer(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    eMsgtNone = _enigma.eGstMsgContainer_eMsgtNone
    eMsgtBusMessage = _enigma.eGstMsgContainer_eMsgtBusMessage
    eMsgtGstStateChange = _enigma.eGstMsgContainer_eMsgtGstStateChange
    eMsgtSubtitleAvailable = _enigma.eGstMsgContainer_eMsgtSubtitleAvailable
    eMsgtSubtitleCaps = _enigma.eGstMsgContainer_eMsgtSubtitleCaps

    def __init__(self, *args):
        _enigma.eGstMsgContainer_swiginit(self, _enigma.new_eGstMsgContainer(*args))
    __swig_destroy__ = _enigma.delete_eGstMsgContainer
eGstMsgContainer.getType = new_instancemethod(_enigma.eGstMsgContainer_getType, None, eGstMsgContainer)
eGstMsgContainer.getTransition = new_instancemethod(_enigma.eGstMsgContainer_getTransition, None, eGstMsgContainer)
eGstMsgContainer.getSource = new_instancemethod(_enigma.eGstMsgContainer_getSource, None, eGstMsgContainer)
eGstMsgContainer_swigregister = _enigma.eGstMsgContainer_swigregister
eGstMsgContainer_swigregister(eGstMsgContainer)

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
    evFileReadError = _enigma.eServiceMP3_ENUMS_evFileReadError
    evTypeNotFoundError = _enigma.eServiceMP3_ENUMS_evTypeNotFoundError
    evGeneralGstError = _enigma.eServiceMP3_ENUMS_evGeneralGstError
    SUB_STREAM_FLAG_SELECT = _enigma.eServiceMP3_ENUMS_SUB_STREAM_FLAG_SELECT
    SUB_STREAM_FLAG_FORCED = _enigma.eServiceMP3_ENUMS_SUB_STREAM_FLAG_FORCED
eServiceMP3_ENUMS_swigregister = _enigma.eServiceMP3_ENUMS_swigregister
eServiceMP3_ENUMS_swigregister(eServiceMP3_ENUMS)

eServiceMP3 = eServiceMP3_ENUMS
class eUriResolver(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, schemas):
        """__init__(eUriResolver self, StringList schemas) -> eUriResolver"""
        if self.__class__ == eUriResolver:
            _self = None
        else:
            _self = self
        _enigma.eUriResolver_swiginit(self, _enigma.new_eUriResolver(_self, schemas))
    __swig_destroy__ = _enigma.delete_eUriResolver

    def resolve(self, service, uri):
        """resolve(eUriResolver self, iUriService service, std::string const & uri) -> bool"""
        return _enigma.eUriResolver_resolve(self, service, uri)


    def schemas(self):
        """schemas(eUriResolver self) -> StringList"""
        return _enigma.eUriResolver_schemas(self)


    def addResolver(resolver):
        """addResolver(eUriResolver resolver)"""
        return _enigma.eUriResolver_addResolver(resolver)

    addResolver = staticmethod(addResolver)

    def removeResolver(resolver):
        """removeResolver(eUriResolver resolver) -> bool"""
        return _enigma.eUriResolver_removeResolver(resolver)

    removeResolver = staticmethod(removeResolver)

    def tryResolveUri(service, uri):
        """tryResolveUri(iUriService service, std::string const & uri) -> bool"""
        return _enigma.eUriResolver_tryResolveUri(service, uri)

    tryResolveUri = staticmethod(tryResolveUri)
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eUriResolver(self)
        return weakref_proxy(self)
eUriResolver.resolve = new_instancemethod(_enigma.eUriResolver_resolve, None, eUriResolver)
eUriResolver.schemas = new_instancemethod(_enigma.eUriResolver_schemas, None, eUriResolver)
eUriResolver_swigregister = _enigma.eUriResolver_swigregister
eUriResolver_swigregister(eUriResolver)

def eUriResolver_addResolver(resolver):
    """eUriResolver_addResolver(eUriResolver resolver)"""
    return _enigma.eUriResolver_addResolver(resolver)

def eUriResolver_removeResolver(resolver):
    """eUriResolver_removeResolver(eUriResolver resolver) -> bool"""
    return _enigma.eUriResolver_removeResolver(resolver)

def eUriResolver_tryResolveUri(service, uri):
    """eUriResolver_tryResolveUri(iUriService service, std::string const & uri) -> bool"""
    return _enigma.eUriResolver_tryResolveUri(service, uri)

class eStreamProcessor(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, name):
        """__init__(eStreamProcessor self, std::string const & name) -> eStreamProcessor"""
        if self.__class__ == eStreamProcessor:
            _self = None
        else:
            _self = self
        _enigma.eStreamProcessor_swiginit(self, _enigma.new_eStreamProcessor(_self, name))
    __swig_destroy__ = _enigma.delete_eStreamProcessor

    def getName(self):
        """getName(eStreamProcessor self) -> std::string const &"""
        return _enigma.eStreamProcessor_getName(self)


    def valid(self):
        """valid(eStreamProcessor self) -> bool"""
        return _enigma.eStreamProcessor_valid(self)


    def start(self):
        """start(eStreamProcessor self)"""
        return _enigma.eStreamProcessor_start(self)


    def stop(self):
        """stop(eStreamProcessor self)"""
        return _enigma.eStreamProcessor_stop(self)


    def pause(self):
        """pause(eStreamProcessor self) -> bool"""
        return _enigma.eStreamProcessor_pause(self)


    def resume(self):
        """resume(eStreamProcessor self) -> bool"""
        return _enigma.eStreamProcessor_resume(self)


    def seekDone(self, status):
        """seekDone(eStreamProcessor self, int status)"""
        return _enigma.eStreamProcessor_seekDone(self, status)


    def flush(self):
        """flush(eStreamProcessor self)"""
        return _enigma.eStreamProcessor_flush(self)


    def canProcess(self, streamInfos):
        """canProcess(eStreamProcessor self, std::vector< StreamInfo,std::allocator< StreamInfo > > & streamInfos) -> bool"""
        return _enigma.eStreamProcessor_canProcess(self, streamInfos)


    def parsed(self):
        """parsed(eStreamProcessor self)"""
        return _enigma.eStreamProcessor_parsed(self)


    def ready(self):
        """ready(eStreamProcessor self)"""
        return _enigma.eStreamProcessor_ready(self)


    def getStreams(self):
        """getStreams(eStreamProcessor self) -> std::vector< StreamInfo,std::allocator< StreamInfo > > &"""
        return _enigma.eStreamProcessor_getStreams(self)


    def selectVideoStream(self, *args):
        """
        selectVideoStream(eStreamProcessor self, int index, StreamRestrictions const & restrictions) -> bool
        selectVideoStream(eStreamProcessor self, int index) -> bool
        """
        return _enigma.eStreamProcessor_selectVideoStream(self, *args)


    def selectAudioStream(self, *args):
        """
        selectAudioStream(eStreamProcessor self, int index, StreamRestrictions const & restrictions) -> bool
        selectAudioStream(eStreamProcessor self, int index) -> bool
        """
        return _enigma.eStreamProcessor_selectAudioStream(self, *args)


    def deleteStream(self, index):
        """deleteStream(eStreamProcessor self, int index)"""
        return _enigma.eStreamProcessor_deleteStream(self, index)


    def getActiveVideoIndex(self):
        """getActiveVideoIndex(eStreamProcessor self) -> int"""
        return _enigma.eStreamProcessor_getActiveVideoIndex(self)


    def getActiveAudioIndex(self):
        """getActiveAudioIndex(eStreamProcessor self) -> int"""
        return _enigma.eStreamProcessor_getActiveAudioIndex(self)


    def getActiveAudioCodec(self):
        """getActiveAudioCodec(eStreamProcessor self) -> int"""
        return _enigma.eStreamProcessor_getActiveAudioCodec(self)


    def getWidth(self, width):
        """getWidth(eStreamProcessor self, int & width) -> bool"""
        return _enigma.eStreamProcessor_getWidth(self, width)


    def getHeight(self, height):
        """getHeight(eStreamProcessor self, int & height) -> bool"""
        return _enigma.eStreamProcessor_getHeight(self, height)


    def getAspect(self, aspect):
        """getAspect(eStreamProcessor self, int & aspect) -> bool"""
        return _enigma.eStreamProcessor_getAspect(self, aspect)


    def getFramerate(self, framerate):
        """getFramerate(eStreamProcessor self, int & framerate) -> bool"""
        return _enigma.eStreamProcessor_getFramerate(self, framerate)


    def getProgressive(self, progressive):
        """getProgressive(eStreamProcessor self, int & progressive) -> bool"""
        return _enigma.eStreamProcessor_getProgressive(self, progressive)


    def isEOS(self):
        """isEOS(eStreamProcessor self) -> bool"""
        return _enigma.eStreamProcessor_isEOS(self)


    def getVideoFrames(self, frames):
        """getVideoFrames(eStreamProcessor self, std::vector< RawData,std::allocator< RawData > > & frames) -> bool"""
        return _enigma.eStreamProcessor_getVideoFrames(self, frames)


    def getAudioPackets(self, packets):
        """getAudioPackets(eStreamProcessor self, std::vector< RawData,std::allocator< RawData > > & packets) -> bool"""
        return _enigma.eStreamProcessor_getAudioPackets(self, packets)


    def getProcessors():
        """getProcessors() -> std::vector< eStreamProcessor *,std::allocator< eStreamProcessor * > > const &"""
        return _enigma.eStreamProcessor_getProcessors()

    getProcessors = staticmethod(getProcessors)

    def addProcessor(processor):
        """addProcessor(eStreamProcessor processor)"""
        return _enigma.eStreamProcessor_addProcessor(processor)

    addProcessor = staticmethod(addProcessor)
    streamStarted = _swig_property(_enigma.eStreamProcessor_streamStarted_get, _enigma.eStreamProcessor_streamStarted_set)
    formatChanged = _swig_property(_enigma.eStreamProcessor_formatChanged_get, _enigma.eStreamProcessor_formatChanged_set)
    framerateChanged = _swig_property(_enigma.eStreamProcessor_framerateChanged_get, _enigma.eStreamProcessor_framerateChanged_set)
    progressiveChanged = _swig_property(_enigma.eStreamProcessor_progressiveChanged_get, _enigma.eStreamProcessor_progressiveChanged_set)
    videoPtsValid = _swig_property(_enigma.eStreamProcessor_videoPtsValid_get, _enigma.eStreamProcessor_videoPtsValid_set)
    lastVideoConsumed = _swig_property(_enigma.eStreamProcessor_lastVideoConsumed_get, _enigma.eStreamProcessor_lastVideoConsumed_set)
    lastAudioConsumed = _swig_property(_enigma.eStreamProcessor_lastAudioConsumed_get, _enigma.eStreamProcessor_lastAudioConsumed_set)
    audioCodecChanged = _swig_property(_enigma.eStreamProcessor_audioCodecChanged_get, _enigma.eStreamProcessor_audioCodecChanged_set)
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eStreamProcessor(self)
        return weakref_proxy(self)
eStreamProcessor.getName = new_instancemethod(_enigma.eStreamProcessor_getName, None, eStreamProcessor)
eStreamProcessor.valid = new_instancemethod(_enigma.eStreamProcessor_valid, None, eStreamProcessor)
eStreamProcessor.start = new_instancemethod(_enigma.eStreamProcessor_start, None, eStreamProcessor)
eStreamProcessor.stop = new_instancemethod(_enigma.eStreamProcessor_stop, None, eStreamProcessor)
eStreamProcessor.pause = new_instancemethod(_enigma.eStreamProcessor_pause, None, eStreamProcessor)
eStreamProcessor.resume = new_instancemethod(_enigma.eStreamProcessor_resume, None, eStreamProcessor)
eStreamProcessor.seekDone = new_instancemethod(_enigma.eStreamProcessor_seekDone, None, eStreamProcessor)
eStreamProcessor.flush = new_instancemethod(_enigma.eStreamProcessor_flush, None, eStreamProcessor)
eStreamProcessor.canProcess = new_instancemethod(_enigma.eStreamProcessor_canProcess, None, eStreamProcessor)
eStreamProcessor.parsed = new_instancemethod(_enigma.eStreamProcessor_parsed, None, eStreamProcessor)
eStreamProcessor.ready = new_instancemethod(_enigma.eStreamProcessor_ready, None, eStreamProcessor)
eStreamProcessor.getStreams = new_instancemethod(_enigma.eStreamProcessor_getStreams, None, eStreamProcessor)
eStreamProcessor.selectVideoStream = new_instancemethod(_enigma.eStreamProcessor_selectVideoStream, None, eStreamProcessor)
eStreamProcessor.selectAudioStream = new_instancemethod(_enigma.eStreamProcessor_selectAudioStream, None, eStreamProcessor)
eStreamProcessor.deleteStream = new_instancemethod(_enigma.eStreamProcessor_deleteStream, None, eStreamProcessor)
eStreamProcessor.getActiveVideoIndex = new_instancemethod(_enigma.eStreamProcessor_getActiveVideoIndex, None, eStreamProcessor)
eStreamProcessor.getActiveAudioIndex = new_instancemethod(_enigma.eStreamProcessor_getActiveAudioIndex, None, eStreamProcessor)
eStreamProcessor.getActiveAudioCodec = new_instancemethod(_enigma.eStreamProcessor_getActiveAudioCodec, None, eStreamProcessor)
eStreamProcessor.getWidth = new_instancemethod(_enigma.eStreamProcessor_getWidth, None, eStreamProcessor)
eStreamProcessor.getHeight = new_instancemethod(_enigma.eStreamProcessor_getHeight, None, eStreamProcessor)
eStreamProcessor.getAspect = new_instancemethod(_enigma.eStreamProcessor_getAspect, None, eStreamProcessor)
eStreamProcessor.getFramerate = new_instancemethod(_enigma.eStreamProcessor_getFramerate, None, eStreamProcessor)
eStreamProcessor.getProgressive = new_instancemethod(_enigma.eStreamProcessor_getProgressive, None, eStreamProcessor)
eStreamProcessor.isEOS = new_instancemethod(_enigma.eStreamProcessor_isEOS, None, eStreamProcessor)
eStreamProcessor.getVideoFrames = new_instancemethod(_enigma.eStreamProcessor_getVideoFrames, None, eStreamProcessor)
eStreamProcessor.getAudioPackets = new_instancemethod(_enigma.eStreamProcessor_getAudioPackets, None, eStreamProcessor)
eStreamProcessor_swigregister = _enigma.eStreamProcessor_swigregister
eStreamProcessor_swigregister(eStreamProcessor)

def eStreamProcessor_getProcessors():
    """eStreamProcessor_getProcessors() -> std::vector< eStreamProcessor *,std::allocator< eStreamProcessor * > > const &"""
    return _enigma.eStreamProcessor_getProcessors()

def eStreamProcessor_addProcessor(processor):
    """eStreamProcessor_addProcessor(eStreamProcessor processor)"""
    return _enigma.eStreamProcessor_addProcessor(processor)

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_PROTOCOL_VERSION = _enigma.eTPM_DT_PROTOCOL_VERSION
    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 eAlsaOutput(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
    HDMI = _enigma.eAlsaOutput_HDMI
    SPDIF = _enigma.eAlsaOutput_SPDIF
    BTPCM = _enigma.eAlsaOutput_BTPCM
    getInstance = staticmethod(_enigma.eAlsaOutput_getInstance)
eAlsaOutput.running = new_instancemethod(_enigma.eAlsaOutput_running, None, eAlsaOutput)
eAlsaOutput.close = new_instancemethod(_enigma.eAlsaOutput_close, None, eAlsaOutput)
eAlsaOutput.stop = new_instancemethod(_enigma.eAlsaOutput_stop, None, eAlsaOutput)
eAlsaOutput_swigregister = _enigma.eAlsaOutput_swigregister
eAlsaOutput_swigregister(eAlsaOutput)

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

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):
        """
        __init__(ePoint self) -> ePoint
        __init__(ePoint self, int xpos, int ypos) -> ePoint
        """
        _enigma.ePoint_swiginit(self, _enigma.new_ePoint(*args))

    def isNull(self):
        """isNull(ePoint self) -> bool"""
        return _enigma.ePoint_isNull(self)


    def x(self):
        """x(ePoint self) -> int"""
        return _enigma.ePoint_x(self)


    def y(self):
        """y(ePoint self) -> int"""
        return _enigma.ePoint_y(self)


    def setX(self, x):
        """setX(ePoint self, int x)"""
        return _enigma.ePoint_setX(self, x)


    def setY(self, y):
        """setY(ePoint self, int y)"""
        return _enigma.ePoint_setY(self, y)


    def manhattanLength(self):
        """manhattanLength(ePoint self) -> int"""
        return _enigma.ePoint_manhattanLength(self)


    def rx(self):
        """rx(ePoint self) -> int &"""
        return _enigma.ePoint_rx(self)


    def ry(self):
        """ry(ePoint self) -> int &"""
        return _enigma.ePoint_ry(self)


    def __iadd__(self, p):
        """__iadd__(ePoint self, ePoint p) -> ePoint"""
        return _enigma.ePoint___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(ePoint self, ePoint p) -> ePoint"""
        return _enigma.ePoint___isub__(self, p)


    def __imul__(self, *args):
        """
        __imul__(ePoint self, int c) -> ePoint
        __imul__(ePoint self, double c) -> ePoint
        """
        return _enigma.ePoint___imul__(self, *args)


    def __itruediv__(self, *args):
        return _enigma.ePoint___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __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_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):
        """
        __init__(eRect self) -> eRect
        __init__(eRect self, ePoint topleft, ePoint bottomright) -> eRect
        __init__(eRect self, ePoint topleft, eSize size) -> eRect
        __init__(eRect self, eSize size) -> eRect
        __init__(eRect self, int width, int height) -> eRect
        __init__(eRect self, int left, int top, int width, int height) -> eRect
        """
        _enigma.eRect_swiginit(self, _enigma.new_eRect(*args))

    def empty(self):
        """empty(eRect self) -> bool"""
        return _enigma.eRect_empty(self)


    def valid(self):
        """valid(eRect self) -> bool"""
        return _enigma.eRect_valid(self)


    def normalize(self):
        """normalize(eRect self) -> eRect"""
        return _enigma.eRect_normalize(self)


    def left(self):
        """left(eRect self) -> int"""
        return _enigma.eRect_left(self)


    def top(self):
        """top(eRect self) -> int"""
        return _enigma.eRect_top(self)


    def right(self):
        """right(eRect self) -> int"""
        return _enigma.eRect_right(self)


    def bottom(self):
        """bottom(eRect self) -> int"""
        return _enigma.eRect_bottom(self)


    def rLeft(self):
        """rLeft(eRect self) -> int &"""
        return _enigma.eRect_rLeft(self)


    def rTop(self):
        """rTop(eRect self) -> int &"""
        return _enigma.eRect_rTop(self)


    def rRight(self):
        """rRight(eRect self) -> int &"""
        return _enigma.eRect_rRight(self)


    def rBottom(self):
        """rBottom(eRect self) -> int &"""
        return _enigma.eRect_rBottom(self)


    def x(self):
        """x(eRect self) -> int"""
        return _enigma.eRect_x(self)


    def y(self):
        """y(eRect self) -> int"""
        return _enigma.eRect_y(self)


    def setLeft(self, pos):
        """setLeft(eRect self, int pos)"""
        return _enigma.eRect_setLeft(self, pos)


    def setTop(self, pos):
        """setTop(eRect self, int pos)"""
        return _enigma.eRect_setTop(self, pos)


    def setRight(self, pos):
        """setRight(eRect self, int pos)"""
        return _enigma.eRect_setRight(self, pos)


    def setBottom(self, pos):
        """setBottom(eRect self, int pos)"""
        return _enigma.eRect_setBottom(self, pos)


    def setX(self, x):
        """setX(eRect self, int x)"""
        return _enigma.eRect_setX(self, x)


    def setY(self, y):
        """setY(eRect self, int y)"""
        return _enigma.eRect_setY(self, y)


    def topLeft(self):
        """topLeft(eRect self) -> ePoint"""
        return _enigma.eRect_topLeft(self)


    def bottomRight(self):
        """bottomRight(eRect self) -> ePoint"""
        return _enigma.eRect_bottomRight(self)


    def topRight(self):
        """topRight(eRect self) -> ePoint"""
        return _enigma.eRect_topRight(self)


    def bottomLeft(self):
        """bottomLeft(eRect self) -> ePoint"""
        return _enigma.eRect_bottomLeft(self)


    def topLeft1(self):
        """topLeft1(eRect self) -> ePoint"""
        return _enigma.eRect_topLeft1(self)


    def bottomRight1(self):
        """bottomRight1(eRect self) -> ePoint"""
        return _enigma.eRect_bottomRight1(self)


    def topRight1(self):
        """topRight1(eRect self) -> ePoint"""
        return _enigma.eRect_topRight1(self)


    def bottomLeft1(self):
        """bottomLeft1(eRect self) -> ePoint"""
        return _enigma.eRect_bottomLeft1(self)


    def center(self):
        """center(eRect self) -> ePoint"""
        return _enigma.eRect_center(self)


    def rect(self, x, y, w, h):
        """rect(eRect self, int * x, int * y, int * w, int * h)"""
        return _enigma.eRect_rect(self, x, y, w, h)


    def coords(self, x1, y1, x2, y2):
        """coords(eRect self, int * x1, int * y1, int * x2, int * y2)"""
        return _enigma.eRect_coords(self, x1, y1, x2, y2)


    def moveTopLeft(self, p):
        """moveTopLeft(eRect self, ePoint p)"""
        return _enigma.eRect_moveTopLeft(self, p)


    def moveBottomRight(self, p):
        """moveBottomRight(eRect self, ePoint p)"""
        return _enigma.eRect_moveBottomRight(self, p)


    def moveTopRight(self, p):
        """moveTopRight(eRect self, ePoint p)"""
        return _enigma.eRect_moveTopRight(self, p)


    def moveBottomLeft(self, p):
        """moveBottomLeft(eRect self, ePoint p)"""
        return _enigma.eRect_moveBottomLeft(self, p)


    def moveCenter(self, p):
        """moveCenter(eRect self, ePoint p)"""
        return _enigma.eRect_moveCenter(self, p)


    def moveBy(self, *args):
        """
        moveBy(eRect self, int dx, int dy)
        moveBy(eRect self, ePoint r)
        """
        return _enigma.eRect_moveBy(self, *args)


    def setRect(self, x, y, w, h):
        """setRect(eRect self, int x, int y, int w, int h)"""
        return _enigma.eRect_setRect(self, x, y, w, h)


    def setCoords(self, x1, y1, x2, y2):
        """setCoords(eRect self, int x1, int y1, int x2, int y2)"""
        return _enigma.eRect_setCoords(self, x1, y1, x2, y2)


    def size(self):
        """size(eRect self) -> eSize"""
        return _enigma.eRect_size(self)


    def width(self):
        """width(eRect self) -> int"""
        return _enigma.eRect_width(self)


    def height(self):
        """height(eRect self) -> int"""
        return _enigma.eRect_height(self)


    def setWidth(self, w):
        """setWidth(eRect self, int w)"""
        return _enigma.eRect_setWidth(self, w)


    def setHeight(self, h):
        """setHeight(eRect self, int h)"""
        return _enigma.eRect_setHeight(self, h)


    def setSize(self, s):
        """setSize(eRect self, eSize s)"""
        return _enigma.eRect_setSize(self, s)


    def setEmpty(self):
        """setEmpty(eRect self)"""
        return _enigma.eRect_setEmpty(self)


    def __or__(self, r):
        """__or__(eRect self, eRect r) -> eRect"""
        return _enigma.eRect___or__(self, r)


    def __and__(self, r):
        """__and__(eRect self, eRect r) -> eRect"""
        return _enigma.eRect___and__(self, r)


    def __ior__(self, r):
        """__ior__(eRect self, eRect r) -> eRect"""
        return _enigma.eRect___ior__(self, r)


    def __iand__(self, r):
        """__iand__(eRect self, eRect r) -> eRect"""
        return _enigma.eRect___iand__(self, r)


    def contains(self, *args):
        """
        contains(eRect self, ePoint p) -> bool
        contains(eRect self, int x, int y) -> bool
        contains(eRect self, eRect r) -> bool
        """
        return _enigma.eRect_contains(self, *args)


    def unite(self, r):
        """unite(eRect self, eRect r) -> eRect"""
        return _enigma.eRect_unite(self, r)


    def intersect(self, r):
        """intersect(eRect self, eRect r) -> eRect"""
        return _enigma.eRect_intersect(self, r)


    def intersects(self, r):
        """intersects(eRect self, eRect r) -> bool"""
        return _enigma.eRect_intersects(self, r)


    def scaleToCenterOf(self, other):
        """scaleToCenterOf(eRect self, eRect other)"""
        return _enigma.eRect_scaleToCenterOf(self, other)


    def scaleToWidthOf(self, other):
        """scaleToWidthOf(eRect self, eRect other)"""
        return _enigma.eRect_scaleToWidthOf(self, other)


    def scaleToHeightOf(self, other):
        """scaleToHeightOf(eRect self, eRect other)"""
        return _enigma.eRect_scaleToHeightOf(self, other)


    def scaleToFill(self, other):
        """scaleToFill(eRect self, eRect other)"""
        return _enigma.eRect_scaleToFill(self, other)


    def centerIn(self, other):
        """centerIn(eRect self, eRect other)"""
        return _enigma.eRect_centerIn(self, other)


    def emptyRect():
        """emptyRect() -> eRect"""
        return _enigma.eRect_emptyRect()

    emptyRect = staticmethod(emptyRect)

    def invalidRect():
        """invalidRect() -> eRect"""
        return _enigma.eRect_invalidRect()

    invalidRect = staticmethod(invalidRect)

    def scale(self, x_n, x_d, y_n, y_d):
        """scale(eRect self, int x_n, int x_d, int y_n, int y_d)"""
        return _enigma.eRect_scale(self, x_n, x_d, y_n, y_d)

    __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.scaleToWidthOf = new_instancemethod(_enigma.eRect_scaleToWidthOf, None, eRect)
eRect.scaleToHeightOf = new_instancemethod(_enigma.eRect_scaleToHeightOf, None, eRect)
eRect.scaleToFill = new_instancemethod(_enigma.eRect_scaleToFill, None, eRect)
eRect.centerIn = new_instancemethod(_enigma.eRect_centerIn, None, eRect)
eRect.scale = new_instancemethod(_enigma.eRect_scale, None, eRect)
eRect_swigregister = _enigma.eRect_swigregister
eRect_swigregister(eRect)

def eRect_emptyRect():
    """eRect_emptyRect() -> eRect"""
    return _enigma.eRect_emptyRect()

def eRect_invalidRect():
    """eRect_invalidRect() -> eRect"""
    return _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):
        """
        __init__(eSize self) -> eSize
        __init__(eSize self, int w, int h) -> eSize
        """
        _enigma.eSize_swiginit(self, _enigma.new_eSize(*args))

    def isNull(self):
        """isNull(eSize self) -> bool"""
        return _enigma.eSize_isNull(self)


    def isEmpty(self):
        """isEmpty(eSize self) -> bool"""
        return _enigma.eSize_isEmpty(self)


    def isValid(self):
        """isValid(eSize self) -> bool"""
        return _enigma.eSize_isValid(self)


    def width(self):
        """width(eSize self) -> int"""
        return _enigma.eSize_width(self)


    def height(self):
        """height(eSize self) -> int"""
        return _enigma.eSize_height(self)


    def setWidth(self, w):
        """setWidth(eSize self, int w)"""
        return _enigma.eSize_setWidth(self, w)


    def setHeight(self, h):
        """setHeight(eSize self, int h)"""
        return _enigma.eSize_setHeight(self, h)


    def transpose(self):
        """transpose(eSize self)"""
        return _enigma.eSize_transpose(self)


    def scale(self, *args):
        """
        scale(eSize self, eSize dst, eSize aspect) -> eSize
        scale(eSize self, eSize dst) -> eSize
        """
        return _enigma.eSize_scale(self, *args)


    def expandedTo(self, arg2):
        """expandedTo(eSize self, eSize arg2) -> eSize"""
        return _enigma.eSize_expandedTo(self, arg2)


    def boundedTo(self, arg2):
        """boundedTo(eSize self, eSize arg2) -> eSize"""
        return _enigma.eSize_boundedTo(self, arg2)


    def rwidth(self):
        """rwidth(eSize self) -> int &"""
        return _enigma.eSize_rwidth(self)


    def rheight(self):
        """rheight(eSize self) -> int &"""
        return _enigma.eSize_rheight(self)


    def __iadd__(self, arg2):
        """__iadd__(eSize self, eSize arg2) -> eSize"""
        return _enigma.eSize___iadd__(self, arg2)


    def __isub__(self, arg2):
        """__isub__(eSize self, eSize arg2) -> eSize"""
        return _enigma.eSize___isub__(self, arg2)


    def __imul__(self, *args):
        """
        __imul__(eSize self, int c) -> eSize
        __imul__(eSize self, double c) -> eSize
        """
        return _enigma.eSize___imul__(self, *args)


    def __itruediv__(self, *args):
        return _enigma.eSize___itruediv__(self, *args)
    __idiv__ = __itruediv__


    __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_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):
        """
        __init__(eMatrix self) -> eMatrix
        __init__(eMatrix self, unsigned int rows, unsigned int columns) -> eMatrix
        __init__(eMatrix self, eMatrix B) -> eMatrix
        """
        _enigma.eMatrix_swiginit(self, _enigma.new_eMatrix(*args))
    __swig_destroy__ = _enigma.delete_eMatrix

    def __call__(self, *args):
        """
        __call__(eMatrix self, unsigned int i, unsigned int j) -> float
        __call__(eMatrix self, unsigned int i, unsigned int j) -> float const &
        """
        return _enigma.eMatrix___call__(self, *args)


    def __eq__(self, B):
        """__eq__(eMatrix self, eMatrix B) -> bool"""
        return _enigma.eMatrix___eq__(self, B)


    def __ne__(self, B):
        """__ne__(eMatrix self, eMatrix B) -> bool"""
        return _enigma.eMatrix___ne__(self, B)


    def __imul__(self, *args):
        """
        __imul__(eMatrix self, eMatrix B) -> eMatrix
        __imul__(eMatrix self, float scalar) -> eMatrix
        """
        return _enigma.eMatrix___imul__(self, *args)


    def __mul__(self, *args):
        """
        __mul__(eMatrix self, eMatrix B) -> eMatrix
        __mul__(eMatrix self, float scalar) -> eMatrix
        """
        return _enigma.eMatrix___mul__(self, *args)


    def __iadd__(self, B):
        """__iadd__(eMatrix self, eMatrix B) -> eMatrix"""
        return _enigma.eMatrix___iadd__(self, B)


    def __add__(self, B):
        """__add__(eMatrix self, eMatrix B) -> eMatrix"""
        return _enigma.eMatrix___add__(self, B)


    def __isub__(self, B):
        """__isub__(eMatrix self, eMatrix B) -> eMatrix"""
        return _enigma.eMatrix___isub__(self, B)


    def __sub__(self, B):
        """__sub__(eMatrix self, eMatrix B) -> eMatrix"""
        return _enigma.eMatrix___sub__(self, B)


    def rows(self):
        """rows(eMatrix self) -> unsigned int"""
        return _enigma.eMatrix_rows(self)


    def columns(self):
        """columns(eMatrix self) -> unsigned int"""
        return _enigma.eMatrix_columns(self)


    def initialize(self, rows, columns, a=None):
        """
        initialize(eMatrix self, unsigned int rows, unsigned int columns, float * a=None)
        initialize(eMatrix self, unsigned int rows, unsigned int columns)
        """
        return _enigma.eMatrix_initialize(self, rows, columns, a)

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.rows = new_instancemethod(_enigma.eMatrix_rows, None, eMatrix)
eMatrix.columns = new_instancemethod(_enigma.eMatrix_columns, None, eMatrix)
eMatrix.initialize = new_instancemethod(_enigma.eMatrix_initialize, 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):
        """
        __init__(eSquareMatrix self, unsigned int order, enum eSquareMatrix::MatrixType type) -> eSquareMatrix
        __init__(eSquareMatrix self, unsigned int order) -> eSquareMatrix
        """
        _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):
        """
        __init__(eMatrix4x4 self, enum eSquareMatrix::MatrixType type) -> eMatrix4x4
        __init__(eMatrix4x4 self) -> eMatrix4x4
        __init__(eMatrix4x4 self, eMatrix B) -> eMatrix4x4
        """
        _enigma.eMatrix4x4_swiginit(self, _enigma.new_eMatrix4x4(*args))

    def __call__(self, *args):
        """
        __call__(eMatrix4x4 self, unsigned int i, unsigned int j) -> float
        __call__(eMatrix4x4 self, unsigned int i, unsigned int j) -> float const &
        """
        return _enigma.eMatrix4x4___call__(self, *args)


    def __imul__(self, *args):
        """
        __imul__(eMatrix4x4 self, eMatrix4x4 B) -> eMatrix4x4
        __imul__(eMatrix4x4 self, float scalar) -> eMatrix4x4
        """
        return _enigma.eMatrix4x4___imul__(self, *args)


    def __mul__(self, *args):
        """
        __mul__(eMatrix4x4 self, eMatrix4x4 B) -> eMatrix4x4
        __mul__(eMatrix4x4 self, float scalar) -> eMatrix4x4
        """
        return _enigma.eMatrix4x4___mul__(self, *args)


    def identity():
        """identity() -> eMatrix4x4"""
        return _enigma.eMatrix4x4_identity()

    identity = staticmethod(identity)

    def orthographic(left, right, top, bottom, near, far):
        """orthographic(float left, float right, float top, float bottom, float near, float far) -> eMatrix4x4"""
        return _enigma.eMatrix4x4_orthographic(left, right, top, bottom, near, far)

    orthographic = staticmethod(orthographic)

    def perspective(angle, near, far, aspect):
        """perspective(float angle, float near, float far, float aspect) -> eMatrix4x4"""
        return _enigma.eMatrix4x4_perspective(angle, near, far, aspect)

    perspective = staticmethod(perspective)

    def rotateX(deg):
        """rotateX(float deg) -> eMatrix4x4"""
        return _enigma.eMatrix4x4_rotateX(deg)

    rotateX = staticmethod(rotateX)

    def rotateY(deg):
        """rotateY(float deg) -> eMatrix4x4"""
        return _enigma.eMatrix4x4_rotateY(deg)

    rotateY = staticmethod(rotateY)

    def rotateZ(deg):
        """rotateZ(float deg) -> eMatrix4x4"""
        return _enigma.eMatrix4x4_rotateZ(deg)

    rotateZ = staticmethod(rotateZ)

    def scale(x, y, z):
        """scale(float x, float y, float z) -> eMatrix4x4"""
        return _enigma.eMatrix4x4_scale(x, y, z)

    scale = staticmethod(scale)

    def translate(self, x, y, z):
        """translate(eMatrix4x4 self, float x, float y, float z) -> eMatrix4x4"""
        return _enigma.eMatrix4x4_translate(self, x, y, z)

    __swig_destroy__ = _enigma.delete_eMatrix4x4
eMatrix4x4.__call__ = new_instancemethod(_enigma.eMatrix4x4___call__, None, eMatrix4x4)
eMatrix4x4.__imul__ = new_instancemethod(_enigma.eMatrix4x4___imul__, None, eMatrix4x4)
eMatrix4x4.__mul__ = new_instancemethod(_enigma.eMatrix4x4___mul__, None, eMatrix4x4)
eMatrix4x4.translate = new_instancemethod(_enigma.eMatrix4x4_translate, None, eMatrix4x4)
eMatrix4x4_swigregister = _enigma.eMatrix4x4_swigregister
eMatrix4x4_swigregister(eMatrix4x4)

def eMatrix4x4_identity():
    """eMatrix4x4_identity() -> eMatrix4x4"""
    return _enigma.eMatrix4x4_identity()

def eMatrix4x4_orthographic(left, right, top, bottom, near, far):
    """eMatrix4x4_orthographic(float left, float right, float top, float bottom, float near, float far) -> eMatrix4x4"""
    return _enigma.eMatrix4x4_orthographic(left, right, top, bottom, near, far)

def eMatrix4x4_perspective(angle, near, far, aspect):
    """eMatrix4x4_perspective(float angle, float near, float far, float aspect) -> eMatrix4x4"""
    return _enigma.eMatrix4x4_perspective(angle, near, far, aspect)

def eMatrix4x4_rotateX(deg):
    """eMatrix4x4_rotateX(float deg) -> eMatrix4x4"""
    return _enigma.eMatrix4x4_rotateX(deg)

def eMatrix4x4_rotateY(deg):
    """eMatrix4x4_rotateY(float deg) -> eMatrix4x4"""
    return _enigma.eMatrix4x4_rotateY(deg)

def eMatrix4x4_rotateZ(deg):
    """eMatrix4x4_rotateZ(float deg) -> eMatrix4x4"""
    return _enigma.eMatrix4x4_rotateZ(deg)

def eMatrix4x4_scale(x, y, z):
    """eMatrix4x4_scale(float x, float y, float z) -> eMatrix4x4"""
    return _enigma.eMatrix4x4_scale(x, y, z)

class eMatrix3d(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, rows, columns, planes):
        """__init__(eMatrix3d self, unsigned int rows, unsigned int columns, unsigned int planes) -> eMatrix3d"""
        _enigma.eMatrix3d_swiginit(self, _enigma.new_eMatrix3d(rows, columns, planes))

    def __call__(self, *args):
        """
        __call__(eMatrix3d self, unsigned int i, unsigned int j, unsigned int k) -> float
        __call__(eMatrix3d self, unsigned int i, unsigned int j, unsigned int k) -> float const &
        """
        return _enigma.eMatrix3d___call__(self, *args)


    def at(self, *args):
        """
        at(eMatrix3d self, size_t n) -> eMatrix
        at(eMatrix3d self, size_t n) -> eMatrix
        """
        return _enigma.eMatrix3d_at(self, *args)

    __swig_destroy__ = _enigma.delete_eMatrix3d
eMatrix3d.__call__ = new_instancemethod(_enigma.eMatrix3d___call__, None, eMatrix3d)
eMatrix3d.at = new_instancemethod(_enigma.eMatrix3d_at, None, eMatrix3d)
eMatrix3d_swigregister = _enigma.eMatrix3d_swigregister
eMatrix3d_swigregister(eMatrix3d)

class eMatrix3d4x4(eMatrix3d):
    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, planes):
        """__init__(eMatrix3d4x4 self, unsigned int planes) -> eMatrix3d4x4"""
        _enigma.eMatrix3d4x4_swiginit(self, _enigma.new_eMatrix3d4x4(planes))

    def __call__(self, *args):
        """
        __call__(eMatrix3d4x4 self, unsigned int i, unsigned int j, unsigned int k) -> float
        __call__(eMatrix3d4x4 self, unsigned int i, unsigned int j, unsigned int k) -> float const &
        """
        return _enigma.eMatrix3d4x4___call__(self, *args)


    def at(self, *args):
        """
        at(eMatrix3d4x4 self, size_t n) -> eMatrix4x4
        at(eMatrix3d4x4 self, size_t n) -> eMatrix4x4
        """
        return _enigma.eMatrix3d4x4_at(self, *args)

    __swig_destroy__ = _enigma.delete_eMatrix3d4x4
eMatrix3d4x4.__call__ = new_instancemethod(_enigma.eMatrix3d4x4___call__, None, eMatrix3d4x4)
eMatrix3d4x4.at = new_instancemethod(_enigma.eMatrix3d4x4_at, None, eMatrix3d4x4)
eMatrix3d4x4_swigregister = _enigma.eMatrix3d4x4_swigregister
eMatrix3d4x4_swigregister(eMatrix3d4x4)

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):
        """
        __init__(gRGBA self, unsigned int r, unsigned int g, unsigned int b, unsigned int a=0xff) -> gRGBA
        __init__(gRGBA self, unsigned int r, unsigned int g, unsigned int b) -> gRGBA
        __init__(gRGBA self) -> gRGBA
        """
        _enigma.gRGBA_swiginit(self, _enigma.new_gRGBA(*args))

    def argb(self):
        """argb(gRGBA self) -> unsigned int"""
        return _enigma.gRGBA_argb(self)


    def fromArgb(c):
        """fromArgb(unsigned int c) -> gRGBA"""
        return _enigma.gRGBA_fromArgb(c)

    fromArgb = staticmethod(fromArgb)

    def __lt__(self, c):
        """__lt__(gRGBA self, gRGBA c) -> bool"""
        return _enigma.gRGBA___lt__(self, c)


    def __eq__(self, c):
        """__eq__(gRGBA self, gRGBA c) -> bool"""
        return _enigma.gRGBA___eq__(self, c)


    def __ne__(self, c):
        """__ne__(gRGBA self, gRGBA c) -> bool"""
        return _enigma.gRGBA___ne__(self, c)


    def premultiplyChannel(c, a):
        """premultiplyChannel(unsigned long c, unsigned long a) -> unsigned long"""
        return _enigma.gRGBA_premultiplyChannel(c, a)

    premultiplyChannel = staticmethod(premultiplyChannel)

    def premultiplyAlpha(self):
        """premultiplyAlpha(gRGBA self) -> gRGBA"""
        return _enigma.gRGBA_premultiplyAlpha(self)


    def set(self, *args):
        """
        set(gRGBA self, unsigned int _r, unsigned int _g, unsigned int _b)
        set(gRGBA self, unsigned int _r, unsigned int _g, unsigned int _b, unsigned int _a)
        """
        return _enigma.gRGBA_set(self, *args)


    def pixel(self, fmt):
        """pixel(gRGBA self, gPixelFormat fmt) -> unsigned int"""
        return _enigma.gRGBA_pixel(self, fmt)


    def fromPixel(self, fmt, pixel):
        """fromPixel(gRGBA self, gPixelFormat fmt, unsigned int pixel)"""
        return _enigma.gRGBA_fromPixel(self, fmt, pixel)

    __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(c):
    """gRGBA_fromArgb(unsigned int c) -> gRGBA"""
    return _enigma.gRGBA_fromArgb(c)

def gRGBA_premultiplyChannel(c, a):
    """gRGBA_premultiplyChannel(unsigned long c, unsigned long a) -> unsigned long"""
    return _enigma.gRGBA_premultiplyChannel(c, a)

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):
        """
        __init__(gRGB self, int _r, int _g, int _b, int _a=0) -> gRGB
        __init__(gRGB self, int _r, int _g, int _b) -> gRGB
        __init__(gRGB self, unsigned int val) -> gRGB
        __init__(gRGB self) -> gRGB
        """
        _enigma.gRGB_swiginit(self, _enigma.new_gRGB(*args))

    def argb(self):
        """argb(gRGB self) -> unsigned int"""
        return _enigma.gRGB_argb(self)

    __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, progress):
        """at(iProgressInterpolator self, float progress) -> float"""
        return _enigma.iProgressInterpolator_at(self, progress)

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, progress):
        """at(eLinearInterpolator self, float progress) -> float"""
        return _enigma.eLinearInterpolator_at(self, progress)

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, progress):
        """at(eAcclerateInterpolator self, float progress) -> float"""
        return _enigma.eAcclerateInterpolator_at(self, progress)

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, progress):
        """at(eDecelerateInterpolator self, float progress) -> float"""
        return _enigma.eDecelerateInterpolator_at(self, progress)

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, progress):
        """at(eOvershootInterpolator self, float progress) -> float"""
        return _enigma.eOvershootInterpolator_at(self, progress)

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, progress):
        """at(eBounceInterpolator self, float progress) -> float"""
        return _enigma.eBounceInterpolator_at(self, progress)

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 setReversed(self, reversed):
        """setReversed(eWidgetAnimationFloat self, bool reversed)"""
        return _enigma.eWidgetAnimationFloat_setReversed(self, reversed)


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


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


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


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


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


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


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

eWidgetAnimationFloat.reset = new_instancemethod(_enigma.eWidgetAnimationFloat_reset, None, eWidgetAnimationFloat)
eWidgetAnimationFloat.setReversed = new_instancemethod(_enigma.eWidgetAnimationFloat_setReversed, 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(duration, arg2, to, reversed=False, interpolator=0):
    return _enigma.eFloatAnimation_create(duration, arg2, to, reversed, interpolator)
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 setReversed(self, reversed):
        """setReversed(eWidgetAnimationPoint self, bool reversed)"""
        return _enigma.eWidgetAnimationPoint_setReversed(self, reversed)


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


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


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


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


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


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


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

eWidgetAnimationPoint.reset = new_instancemethod(_enigma.eWidgetAnimationPoint_reset, None, eWidgetAnimationPoint)
eWidgetAnimationPoint.setReversed = new_instancemethod(_enigma.eWidgetAnimationPoint_setReversed, 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, ms, reverse=False):
        """
        at(ePointAnimation self, int64_t ms, bool reverse=False) -> ePoint
        at(ePointAnimation self, int64_t ms) -> ePoint
        """
        return _enigma.ePointAnimation_at(self, ms, reverse)


    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)


    def getFactor(self):
        """getFactor(ePointAnimation self) -> float"""
        return _enigma.ePointAnimation_getFactor(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.getFactor = new_instancemethod(_enigma.ePointAnimation_getFactor, None, ePointAnimation)
ePointAnimation_swigregister = _enigma.ePointAnimation_swigregister
ePointAnimation_swigregister(ePointAnimation)

def ePointAnimation_create(duration, arg2, to, factor, reversed=False, interpolator=0, reverse_animation=False, animateX=True, animateY=True):
    return _enigma.ePointAnimation_create(duration, arg2, to, factor, reversed, interpolator, reverse_animation, animateX, animateY)
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 setReversed(self, reversed):
        """setReversed(eWidgetAnimationSize self, bool reversed)"""
        return _enigma.eWidgetAnimationSize_setReversed(self, reversed)


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


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


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


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


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


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


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

eWidgetAnimationSize.reset = new_instancemethod(_enigma.eWidgetAnimationSize_reset, None, eWidgetAnimationSize)
eWidgetAnimationSize.setReversed = new_instancemethod(_enigma.eWidgetAnimationSize_setReversed, 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(duration, arg2, to, reversed=False, interpolator=0, reverse_animation=False, animateW=True, animateH=True, centered=False):
    return _enigma.eSizeAnimation_create(duration, arg2, to, reversed, interpolator, reverse_animation, animateW, animateH, centered)
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 setReversed(self, reversed):
        """setReversed(eWidgetAnimationMatrix self, bool reversed)"""
        return _enigma.eWidgetAnimationMatrix_setReversed(self, reversed)


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


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


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


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


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


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


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

eWidgetAnimationMatrix.reset = new_instancemethod(_enigma.eWidgetAnimationMatrix_reset, None, eWidgetAnimationMatrix)
eWidgetAnimationMatrix.setReversed = new_instancemethod(_enigma.eWidgetAnimationMatrix_setReversed, 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(duration, arg2, to, reversed=False, interpolator=0):
    return _enigma.eMatrixAnimation_create(duration, arg2, to, reversed, interpolator)
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, alpha):
        """setAlphaAnimation(eWidgetAnimationSet self, eFloatAnimation alpha)"""
        return _enigma.eWidgetAnimationSet_setAlphaAnimation(self, alpha)


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


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


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


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


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


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


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


    def recalcPosition(self, parentSize):
        """recalcPosition(eWidgetAnimationSet self, eSize parentSize)"""
        return _enigma.eWidgetAnimationSet_recalcPosition(self, parentSize)

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.recalcPosition = new_instancemethod(_enigma.eWidgetAnimationSet_recalcPosition, 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, internal):
        """setInternal(eWindowAnimationSet self, bool internal)"""
        return _enigma.eWindowAnimationSet_setInternal(self, internal)


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


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


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


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


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


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


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


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


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


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

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)
    setWidgetDefault = staticmethod(_enigma.eWindowAnimationManager_setWidgetDefault)
    isWidgetAnimationsEnabled = staticmethod(_enigma.eWindowAnimationManager_isWidgetAnimationsEnabled)
    setWidgetAnimationsEnabled = staticmethod(_enigma.eWindowAnimationManager_setWidgetAnimationsEnabled)
    defaultAnimationChanged = _swig_property(_enigma.eWindowAnimationManager_defaultAnimationChanged_get, _enigma.eWindowAnimationManager_defaultAnimationChanged_set)
    defaultWidgetAnimationChanged = _swig_property(_enigma.eWindowAnimationManager_defaultWidgetAnimationChanged_get, _enigma.eWindowAnimationManager_defaultWidgetAnimationChanged_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(set):
    return _enigma.eWindowAnimationManager_setAnimationSet(set)
eWindowAnimationManager_setAnimationSet = _enigma.eWindowAnimationManager_setAnimationSet

def eWindowAnimationManager_getAnimationSet(key):
    return _enigma.eWindowAnimationManager_getAnimationSet(key)
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(enabled):
    return _enigma.eWindowAnimationManager_setAnimationsEnabled(enabled)
eWindowAnimationManager_setAnimationsEnabled = _enigma.eWindowAnimationManager_setAnimationsEnabled

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

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

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

def eWindowAnimationManager_setWidgetAnimationsEnabled(enabled):
    return _enigma.eWindowAnimationManager_setWidgetAnimationsEnabled(enabled)
eWindowAnimationManager_setWidgetAnimationsEnabled = _enigma.eWindowAnimationManager_setWidgetAnimationsEnabled

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, parent):
        """__init__(eWidget self, eWidget parent) -> eWidget"""
        _enigma.eWidget_swiginit(self, _enigma.new_eWidget(parent))
    __swig_destroy__ = _enigma.delete_eWidget

    def move(self, pos):
        """move(eWidget self, ePoint pos)"""
        return _enigma.eWidget_move(self, pos)


    def resize(self, size):
        """resize(eWidget self, eSize size)"""
        return _enigma.eWidget_resize(self, size)


    def position(self):
        """position(eWidget self) -> ePoint"""
        return _enigma.eWidget_position(self)


    def size(self):
        """size(eWidget self) -> eSize"""
        return _enigma.eWidget_size(self)


    def csize(self):
        """csize(eWidget self) -> eSize"""
        return _enigma.eWidget_csize(self)


    def parent(self):
        """parent(eWidget self) -> eWidget"""
        return _enigma.eWidget_parent(self)


    def parentSize(self):
        """parentSize(eWidget self) -> eSize"""
        return _enigma.eWidget_parentSize(self)


    def parentCsize(self):
        """parentCsize(eWidget self) -> eSize"""
        return _enigma.eWidget_parentCsize(self)


    def invalidate(self, *args):
        """
        invalidate(eWidget self, gRegion const & region)
        invalidate(eWidget self)
        """
        return _enigma.eWidget_invalidate(self, *args)


    def invalidateForAnimation(self):
        """invalidateForAnimation(eWidget self)"""
        return _enigma.eWidget_invalidateForAnimation(self)


    def child(self):
        """child(eWidget self) -> eWidget"""
        return _enigma.eWidget_child(self)


    def show(self):
        """show(eWidget self)"""
        return _enigma.eWidget_show(self)


    def hide(self):
        """hide(eWidget self)"""
        return _enigma.eWidget_hide(self)


    def doHide(self):
        """doHide(eWidget self)"""
        return _enigma.eWidget_doHide(self)


    def destruct(self):
        """destruct(eWidget self)"""
        return _enigma.eWidget_destruct(self)


    def getStyle(self, OUTPUT):
        """getStyle(eWidget self, eWindowStylePtr OUTPUT)"""
        return _enigma.eWidget_getStyle(self, OUTPUT)


    def setStyle(self, style):
        """setStyle(eWidget self, eWindowStyle * style)"""
        return _enigma.eWidget_setStyle(self, style)


    def setBackgroundColor(self, col):
        """setBackgroundColor(eWidget self, gRGB col)"""
        return _enigma.eWidget_setBackgroundColor(self, col)


    def clearBackgroundColor(self):
        """clearBackgroundColor(eWidget self)"""
        return _enigma.eWidget_clearBackgroundColor(self)


    def setZPosition(self, z):
        """setZPosition(eWidget self, int z)"""
        return _enigma.eWidget_setZPosition(self, z)


    def setTransparent(self, transp):
        """setTransparent(eWidget self, int transp)"""
        return _enigma.eWidget_setTransparent(self, transp)


    def isVisible(self):
        """isVisible(eWidget self) -> int"""
        return _enigma.eWidget_isVisible(self)


    def isFading(self):
        """isFading(eWidget self) -> bool const"""
        return _enigma.eWidget_isFading(self)


    def disable(self):
        """disable(eWidget self)"""
        return _enigma.eWidget_disable(self)


    def enable(self):
        """enable(eWidget self)"""
        return _enigma.eWidget_enable(self)


    def isEnabled(self):
        """isEnabled(eWidget self) -> bool"""
        return _enigma.eWidget_isEnabled(self)


    def onAnimationFinished(self):
        """onAnimationFinished(eWidget self)"""
        return _enigma.eWidget_onAnimationFinished(self)


    def signalHideAnimationFinished(self):
        """signalHideAnimationFinished(eWidget self)"""
        return _enigma.eWidget_signalHideAnimationFinished(self)


    def canAnimate(self):
        """canAnimate(eWidget self) -> bool"""
        return _enigma.eWidget_canAnimate(self)


    def isFinishedAnimating(self):
        """isFinishedAnimating(eWidget self) -> bool"""
        return _enigma.eWidget_isFinishedAnimating(self)


    def setParentTitle(self, title):
        """setParentTitle(eWidget self, std::string const & title)"""
        return _enigma.eWidget_setParentTitle(self, title)


    def setShowHideAnimation(self, key):
        """setShowHideAnimation(eWidget self, std::string const & key) -> bool"""
        return _enigma.eWidget_setShowHideAnimation(self, key)


    def setPulsate(self, enabled, duration=1000, arg4=0.3, to=1.0):
        """
        setPulsate(eWidget self, bool enabled, int64_t duration=1000, float arg4=0.3, float to=1.0)
        setPulsate(eWidget self, bool enabled, int64_t duration=1000, float arg4=0.3)
        setPulsate(eWidget self, bool enabled, int64_t duration=1000)
        setPulsate(eWidget self, bool enabled)
        """
        return _enigma.eWidget_setPulsate(self, enabled, duration, arg4, to)


    def isTransparent(self):
        """isTransparent(eWidget self) -> int"""
        return _enigma.eWidget_isTransparent(self)


    def getAbsolutePosition(self):
        """getAbsolutePosition(eWidget self) -> ePoint"""
        return _enigma.eWidget_getAbsolutePosition(self)

    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
    evtPrefetch = _enigma.eWidget_evtPrefetch
    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

    def event(self, event, data=None, data2=None):
        """
        event(eWidget self, int event, void * data=None, void * data2=None) -> int
        event(eWidget self, int event, void * data=None) -> int
        event(eWidget self, int event) -> int
        """
        return _enigma.eWidget_event(self, event, data, data2)


    def setFocus(self, focus):
        """setFocus(eWidget self, eWidget focus)"""
        return _enigma.eWidget_setFocus(self, focus)


    def setPositionNotifyChild(self, n):
        """setPositionNotifyChild(eWidget self, int n)"""
        return _enigma.eWidget_setPositionNotifyChild(self, n)


    def notifyShowHide(self):
        """notifyShowHide(eWidget self)"""
        return _enigma.eWidget_notifyShowHide(self)

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.parent = new_instancemethod(_enigma.eWidget_parent, 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.setShowHideAnimation = new_instancemethod(_enigma.eWidget_setShowHideAnimation, 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(which):
    return _enigma.getDesktop(which)
getDesktop = _enigma.getDesktop
class eAnimatedWidget(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, parent):
        """__init__(eAnimatedWidget self, eWidget parent) -> eAnimatedWidget"""
        _enigma.eAnimatedWidget_swiginit(self, _enigma.new_eAnimatedWidget(parent))
    __swig_destroy__ = _enigma.delete_eAnimatedWidget

    def setAlphatest(self, flag):
        """setAlphatest(eAnimatedWidget self, int flag)"""
        return _enigma.eAnimatedWidget_setAlphatest(self, flag)


    def doBlit(self, *args):
        """
        doBlit(eAnimatedWidget self, gPainter & painter, gPixmapPtr m_pixmap, eRect scaleDest, bool reverse)
        doBlit(eAnimatedWidget self, gPainter & painter)
        """
        return _enigma.eAnimatedWidget_doBlit(self, *args)


    def prepareForChangeAnimation(self):
        """prepareForChangeAnimation(eAnimatedWidget self) -> bool"""
        return _enigma.eAnimatedWidget_prepareForChangeAnimation(self)


    def setDefaultAnimationEnabled(self, enabled):
        """setDefaultAnimationEnabled(eAnimatedWidget self, bool enabled)"""
        return _enigma.eAnimatedWidget_setDefaultAnimationEnabled(self, enabled)

eAnimatedWidget.setAlphatest = new_instancemethod(_enigma.eAnimatedWidget_setAlphatest, None, eAnimatedWidget)
eAnimatedWidget.doBlit = new_instancemethod(_enigma.eAnimatedWidget_doBlit, None, eAnimatedWidget)
eAnimatedWidget.prepareForChangeAnimation = new_instancemethod(_enigma.eAnimatedWidget_prepareForChangeAnimation, None, eAnimatedWidget)
eAnimatedWidget.setDefaultAnimationEnabled = new_instancemethod(_enigma.eAnimatedWidget_setDefaultAnimationEnabled, None, eAnimatedWidget)
eAnimatedWidget_swigregister = _enigma.eAnimatedWidget_swigregister
eAnimatedWidget_swigregister(eAnimatedWidget)

class eLabel(eAnimatedWidget):
    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, parent, markedPos=-1):
        """
        __init__(eLabel self, eWidget parent, int markedPos=-1) -> eLabel
        __init__(eLabel self, eWidget parent) -> eLabel
        """
        _enigma.eLabel_swiginit(self, _enigma.new_eLabel(parent, markedPos))

    def setText(self, string):
        """setText(eLabel self, std::string const & string)"""
        return _enigma.eLabel_setText(self, string)


    def setMarkedPos(self, markedPos):
        """setMarkedPos(eLabel self, int markedPos)"""
        return _enigma.eLabel_setMarkedPos(self, markedPos)


    def setFont(self, font):
        """setFont(eLabel self, gFont font)"""
        return _enigma.eLabel_setFont(self, font)


    def getFont(self):
        """getFont(eLabel self) -> gFont"""
        return _enigma.eLabel_getFont(self)

    alignLeft = _enigma.eLabel_alignLeft
    alignTop = _enigma.eLabel_alignTop
    alignCenter = _enigma.eLabel_alignCenter
    alignRight = _enigma.eLabel_alignRight
    alignBottom = _enigma.eLabel_alignBottom
    alignBlock = _enigma.eLabel_alignBlock
    alignCenterOrBottom = _enigma.eLabel_alignCenterOrBottom
    alignCenterOrRight = _enigma.eLabel_alignCenterOrRight

    def setVAlign(self, align):
        """setVAlign(eLabel self, int align)"""
        return _enigma.eLabel_setVAlign(self, align)


    def setHAlign(self, align):
        """setHAlign(eLabel self, int align)"""
        return _enigma.eLabel_setHAlign(self, align)


    def setForegroundColor(self, col):
        """setForegroundColor(eLabel self, gRGB col)"""
        return _enigma.eLabel_setForegroundColor(self, col)


    def setShadowColor(self, col):
        """setShadowColor(eLabel self, gRGB col)"""
        return _enigma.eLabel_setShadowColor(self, col)


    def setShadowOffset(self, offset):
        """setShadowOffset(eLabel self, ePoint offset)"""
        return _enigma.eLabel_setShadowOffset(self, offset)


    def setNoWrap(self, nowrap):
        """setNoWrap(eLabel self, int nowrap)"""
        return _enigma.eLabel_setNoWrap(self, nowrap)


    def clearForegroundColor(self):
        """clearForegroundColor(eLabel self)"""
        return _enigma.eLabel_clearForegroundColor(self)


    def setCornerRadius(self, value):
        """setCornerRadius(eLabel self, unsigned int value)"""
        return _enigma.eLabel_setCornerRadius(self, value)


    def setPadding(self, value):
        """setPadding(eLabel self, ePoint value)"""
        return _enigma.eLabel_setPadding(self, value)


    def calculateSize(self):
        """calculateSize(eLabel self) -> eSize"""
        return _enigma.eLabel_calculateSize(self)

    __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.setCornerRadius = new_instancemethod(_enigma.eLabel_setCornerRadius, None, eLabel)
eLabel.setPadding = new_instancemethod(_enigma.eLabel_setPadding, None, eLabel)
eLabel.calculateSize = new_instancemethod(_enigma.eLabel_calculateSize, None, eLabel)
eLabel_swigregister = _enigma.eLabel_swigregister
eLabel_swigregister(eLabel)

class ePixmap(eAnimatedWidget):
    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, parent):
        """__init__(ePixmap self, eWidget parent) -> ePixmap"""
        _enigma.ePixmap_swiginit(self, _enigma.new_ePixmap(parent))

    def setPixmap(self, pixmap):
        """setPixmap(ePixmap self, gPixmapPtr pixmap)"""
        return _enigma.ePixmap_setPixmap(self, pixmap)


    def setPixmapFromFile(self, filename):
        """setPixmapFromFile(ePixmap self, char const * filename) -> bool"""
        return _enigma.ePixmap_setPixmapFromFile(self, filename)


    def setPixmapFromUI(self, *args):
        """
        setPixmapFromUI(ePixmap self, eSize size, int desktop=0) -> bool
        setPixmapFromUI(ePixmap self, eSize size) -> bool
        setPixmapFromUI(ePixmap self) -> bool
        """
        return _enigma.ePixmap_setPixmapFromUI(self, *args)


    def setPixmapFromScreen(self, *args):
        """
        setPixmapFromScreen(ePixmap self, eSize size) -> bool
        setPixmapFromScreen(ePixmap self) -> bool
        """
        return _enigma.ePixmap_setPixmapFromScreen(self, *args)


    def setPixmapFromVideo(self, *args):
        """
        setPixmapFromVideo(ePixmap self, unsigned int decoder=0, eSize size) -> bool
        setPixmapFromVideo(ePixmap self, unsigned int decoder=0) -> bool
        setPixmapFromVideo(ePixmap self) -> bool
        """
        return _enigma.ePixmap_setPixmapFromVideo(self, *args)


    def setScale(self, scale):
        """setScale(ePixmap self, int scale)"""
        return _enigma.ePixmap_setScale(self, scale)


    def setScaleDest(self, rect):
        """setScaleDest(ePixmap self, eRect rect)"""
        return _enigma.ePixmap_setScaleDest(self, rect)


    def setBorderWidth(self, pixel):
        """setBorderWidth(ePixmap self, int pixel)"""
        return _enigma.ePixmap_setBorderWidth(self, pixel)


    def setBorderColor(self, color):
        """setBorderColor(ePixmap self, gRGB color)"""
        return _enigma.ePixmap_setBorderColor(self, color)


    def setGradient(self, arg2, to, direction):
        """setGradient(ePixmap self, gRGBA arg2, gRGBA to, int direction)"""
        return _enigma.ePixmap_setGradient(self, arg2, to, direction)

    GRADIENT_HORIZONTAL = _enigma.ePixmap_GRADIENT_HORIZONTAL
    GRADIENT_VERTICAL = _enigma.ePixmap_GRADIENT_VERTICAL
    GRADIENT_HORIZONTAL_CENTERED = _enigma.ePixmap_GRADIENT_HORIZONTAL_CENTERED
    GRADIENT_VERTICAL_CENTERED = _enigma.ePixmap_GRADIENT_VERTICAL_CENTERED
    FMT_GIF = _enigma.ePixmap_FMT_GIF
    FMT_JPEG = _enigma.ePixmap_FMT_JPEG
    FMT_PNG = _enigma.ePixmap_FMT_PNG
    SCALE_TYPE_NONE = _enigma.ePixmap_SCALE_TYPE_NONE
    SCALE_TYPE_ASPECT = _enigma.ePixmap_SCALE_TYPE_ASPECT
    SCALE_TYPE_CENTER = _enigma.ePixmap_SCALE_TYPE_CENTER
    SCALE_TYPE_WIDTH = _enigma.ePixmap_SCALE_TYPE_WIDTH
    SCALE_TYPE_HEIGHT = _enigma.ePixmap_SCALE_TYPE_HEIGHT
    SCALE_TYPE_STRETCH = _enigma.ePixmap_SCALE_TYPE_STRETCH
    SCALE_TYPE_FILL = _enigma.ePixmap_SCALE_TYPE_FILL

    def save(self, *args):
        """
        save(ePixmap self, enum ePixmap::FileFormat fmt, char const * filename) -> bool
        save(ePixmap self, enum ePixmap::FileFormat fmt) -> BufferPtr
        """
        return _enigma.ePixmap_save(self, *args)

    __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.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.setGradient = new_instancemethod(_enigma.ePixmap_setGradient, 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, parent):
        """__init__(eCanvas self, eWidget parent) -> eCanvas"""
        _enigma.eCanvas_swiginit(self, _enigma.new_eCanvas(parent))

    def prepareForChangeAnimation(self):
        """prepareForChangeAnimation(eCanvas self) -> bool"""
        return _enigma.eCanvas_prepareForChangeAnimation(self)


    def setSize(self, size):
        """setSize(eCanvas self, eSize size)"""
        return _enigma.eCanvas_setSize(self, size)


    def clear(self, color):
        """clear(eCanvas self, gRGBA color)"""
        return _enigma.eCanvas_clear(self, color)


    def fillRect(self, rect, color):
        """fillRect(eCanvas self, eRect rect, gRGBA color)"""
        return _enigma.eCanvas_fillRect(self, rect, color)


    def writeText(self, where, fg, bg, font, string, flags):
        """writeText(eCanvas self, eRect where, gRGBA fg, gRGBA bg, gFont font, char const * string, int flags)"""
        return _enigma.eCanvas_writeText(self, where, fg, bg, font, string, flags)

    __swig_destroy__ = _enigma.delete_eCanvas
eCanvas.prepareForChangeAnimation = new_instancemethod(_enigma.eCanvas_prepareForChangeAnimation, None, 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, parent):
        """__init__(eButton self, eWidget parent) -> eButton"""
        _enigma.eButton_swiginit(self, _enigma.new_eButton(parent))
    selected = _swig_property(_enigma.eButton_selected_get, _enigma.eButton_selected_set)

    def push(self):
        """push(eButton self)"""
        return _enigma.eButton_push(self)

    __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, desktop, z=0):
        """
        __init__(eWindow self, eWidgetDesktop desktop, int z=0) -> eWindow
        __init__(eWindow self, eWidgetDesktop desktop) -> eWindow
        """
        _enigma.eWindow_swiginit(self, _enigma.new_eWindow(desktop, z))
    __swig_destroy__ = _enigma.delete_eWindow

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


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


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

    wfNoBorder = _enigma.eWindow_wfNoBorder

    def setBackgroundColor(self, col):
        """setBackgroundColor(eWindow self, gRGB col)"""
        return _enigma.eWindow_setBackgroundColor(self, col)


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


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

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, parent):
        """__init__(eSlider self, eWidget parent) -> eSlider"""
        _enigma.eSlider_swiginit(self, _enigma.new_eSlider(parent))

    def setValue(self, val):
        """setValue(eSlider self, int val)"""
        return _enigma.eSlider_setValue(self, val)


    def setStartEnd(self, start, end):
        """setStartEnd(eSlider self, int start, int end)"""
        return _enigma.eSlider_setStartEnd(self, start, end)


    def setRange(self, min, max):
        """setRange(eSlider self, int min, int max)"""
        return _enigma.eSlider_setRange(self, min, max)

    orHorizontal = _enigma.eSlider_orHorizontal
    orVertical = _enigma.eSlider_orVertical

    def setOrientation(self, orientation, swapped=0, reset=False):
        """
        setOrientation(eSlider self, int orientation, int swapped=0, bool reset=False)
        setOrientation(eSlider self, int orientation, int swapped=0)
        setOrientation(eSlider self, int orientation)
        """
        return _enigma.eSlider_setOrientation(self, orientation, swapped, reset)


    def setBorderWidth(self, pixel):
        """setBorderWidth(eSlider self, int pixel)"""
        return _enigma.eSlider_setBorderWidth(self, pixel)


    def setBorderColor(self, color):
        """setBorderColor(eSlider self, gRGB color)"""
        return _enigma.eSlider_setBorderColor(self, color)


    def setPixmap(self, pixmap):
        """setPixmap(eSlider self, gPixmapPtr pixmap)"""
        return _enigma.eSlider_setPixmap(self, pixmap)


    def setValuePixmap(self, pixmap):
        """setValuePixmap(eSlider self, gPixmapPtr pixmap)"""
        return _enigma.eSlider_setValuePixmap(self, pixmap)


    def setBackgroundPixmap(self, pixmap):
        """setBackgroundPixmap(eSlider self, gPixmapPtr pixmap)"""
        return _enigma.eSlider_setBackgroundPixmap(self, pixmap)


    def setBackgroundPixmapTopHeight(self, value):
        """setBackgroundPixmapTopHeight(eSlider self, int value)"""
        return _enigma.eSlider_setBackgroundPixmapTopHeight(self, value)


    def setBackgroundPixmapBottomHeight(self, value):
        """setBackgroundPixmapBottomHeight(eSlider self, int value)"""
        return _enigma.eSlider_setBackgroundPixmapBottomHeight(self, value)


    def setValuePixmapTopHeight(self, value):
        """setValuePixmapTopHeight(eSlider self, int value)"""
        return _enigma.eSlider_setValuePixmapTopHeight(self, value)


    def setValuePixmapBottomHeight(self, value):
        """setValuePixmapBottomHeight(eSlider self, int value)"""
        return _enigma.eSlider_setValuePixmapBottomHeight(self, value)


    def clearProperties(self):
        """clearProperties(eSlider self)"""
        return _enigma.eSlider_clearProperties(self)


    def updateScrollLabelProperties(self, arg2, arg3):
        """updateScrollLabelProperties(eSlider self, int & arg2, int & arg3)"""
        return _enigma.eSlider_updateScrollLabelProperties(self, arg2, arg3)


    def setBackgroundColor(self, color):
        """setBackgroundColor(eSlider self, gRGB color)"""
        return _enigma.eSlider_setBackgroundColor(self, color)


    def setForegroundColor(self, color):
        """setForegroundColor(eSlider self, gRGB color)"""
        return _enigma.eSlider_setForegroundColor(self, color)

    __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.setBackgroundColor = new_instancemethod(_enigma.eSlider_setBackgroundColor, None, eSlider)
eSlider.setForegroundColor = new_instancemethod(_enigma.eSlider_setForegroundColor, 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, parent):
        """__init__(ePositionGauge self, eWidget parent) -> ePositionGauge"""
        _enigma.ePositionGauge_swiginit(self, _enigma.new_ePositionGauge(parent))
    __swig_destroy__ = _enigma.delete_ePositionGauge

    def setLength(self, len):
        """setLength(ePositionGauge self, pts_t const & len)"""
        return _enigma.ePositionGauge_setLength(self, len)


    def setPosition(self, pos):
        """setPosition(ePositionGauge self, pts_t const & pos)"""
        return _enigma.ePositionGauge_setPosition(self, pos)


    def setInColor(self, color):
        """setInColor(ePositionGauge self, gRGB color)"""
        return _enigma.ePositionGauge_setInColor(self, color)


    def setPointer(self, which, pixmap, center):
        """setPointer(ePositionGauge self, int which, gPixmapPtr pixmap, ePoint center)"""
        return _enigma.ePositionGauge_setPointer(self, which, pixmap, center)


    def setInOutList(self, list):
        """setInOutList(ePositionGauge self, std::list< std::pair< pts_t,unsigned int >,std::allocator< std::pair< pts_t,unsigned int > > > list)"""
        return _enigma.ePositionGauge_setInOutList(self, list)


    def setForegroundColor(self, col):
        """setForegroundColor(ePositionGauge self, gRGB col)"""
        return _enigma.ePositionGauge_setForegroundColor(self, col)


    def enableSeekPointer(self, enable):
        """enableSeekPointer(ePositionGauge self, int enable)"""
        return _enigma.ePositionGauge_enableSeekPointer(self, enable)


    def setSeekPosition(self, pos):
        """setSeekPosition(ePositionGauge self, pts_t const & pos)"""
        return _enigma.ePositionGauge_setSeekPosition(self, pos)

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, screen):
        """__init__(eWidgetDesktop self, eSize screen) -> eWidgetDesktop"""
        _enigma.eWidgetDesktop_swiginit(self, _enigma.new_eWidgetDesktop(screen))
    __swig_destroy__ = _enigma.delete_eWidgetDesktop

    def addRootWidget(self, root):
        """addRootWidget(eWidgetDesktop self, eWidget root)"""
        return _enigma.eWidgetDesktop_addRootWidget(self, root)


    def removeRootWidget(self, root):
        """removeRootWidget(eWidgetDesktop self, eWidget root)"""
        return _enigma.eWidgetDesktop_removeRootWidget(self, root)


    def movedWidget(self, root):
        """movedWidget(eWidgetDesktop self, eWidget root) -> bool"""
        return _enigma.eWidgetDesktop_movedWidget(self, root)


    def recalcClipRegions(self, root):
        """recalcClipRegions(eWidgetDesktop self, eWidget root)"""
        return _enigma.eWidgetDesktop_recalcClipRegions(self, root)


    def invalidate(self, region, widget=None):
        """
        invalidate(eWidgetDesktop self, gRegion const & region, eWidget widget=None)
        invalidate(eWidgetDesktop self, gRegion const & region)
        """
        return _enigma.eWidgetDesktop_invalidate(self, region, widget)


    def requireNotify(self):
        """requireNotify(eWidgetDesktop self)"""
        return _enigma.eWidgetDesktop_requireNotify(self)


    def paint(self):
        """paint(eWidgetDesktop self)"""
        return _enigma.eWidgetDesktop_paint(self)


    def setDC(self, dc):
        """setDC(eWidgetDesktop self, gDC * dc)"""
        return _enigma.eWidgetDesktop_setDC(self, dc)


    def setBackgroundColor(self, col):
        """setBackgroundColor(eWidgetDesktop self, gRGBA col)"""
        return _enigma.eWidgetDesktop_setBackgroundColor(self, col)


    def setPalette(self, pm):
        """setPalette(eWidgetDesktop self, gPixmapPtr pm)"""
        return _enigma.eWidgetDesktop_setPalette(self, pm)


    def setRedrawTask(self, ml):
        """setRedrawTask(eWidgetDesktop self, eMainloop ml)"""
        return _enigma.eWidgetDesktop_setRedrawTask(self, ml)


    def makeCompatiblePixmap(self, *args):
        """
        makeCompatiblePixmap(eWidgetDesktop self, gPixmapPtr pm)
        makeCompatiblePixmap(eWidgetDesktop self, gPixmap & pm)
        """
        return _enigma.eWidgetDesktop_makeCompatiblePixmap(self, *args)


    def pixelFormat(self):
        """pixelFormat(eWidgetDesktop self) -> gPixelFormat"""
        return _enigma.eWidgetDesktop_pixelFormat(self)

    cmImmediate = _enigma.eWidgetDesktop_cmImmediate
    cmBuffered = _enigma.eWidgetDesktop_cmBuffered

    def compositionMode(self):
        """compositionMode(eWidgetDesktop self) -> int"""
        return _enigma.eWidgetDesktop_compositionMode(self)


    def setCompositionMode(self, mode):
        """setCompositionMode(eWidgetDesktop self, int mode)"""
        return _enigma.eWidgetDesktop_setCompositionMode(self, mode)

    off = _enigma.eWidgetDesktop_off
    sbs = _enigma.eWidgetDesktop_sbs
    tab = _enigma.eWidgetDesktop_tab

    def get3dMode(self):
        """get3dMode(eWidgetDesktop self) -> int"""
        return _enigma.eWidgetDesktop_get3dMode(self)


    def set3dMode(self, mode):
        """set3dMode(eWidgetDesktop self, int mode)"""
        return _enigma.eWidgetDesktop_set3dMode(self, mode)


    def set3dOffset(self, offset):
        """set3dOffset(eWidgetDesktop self, int offset)"""
        return _enigma.eWidgetDesktop_set3dOffset(self, offset)


    def getStyleID(self):
        """getStyleID(eWidgetDesktop self) -> int"""
        return _enigma.eWidgetDesktop_getStyleID(self)


    def setStyleID(self, id):
        """setStyleID(eWidgetDesktop self, int id)"""
        return _enigma.eWidgetDesktop_setStyleID(self, id)


    def resize(self, size):
        """resize(eWidgetDesktop self, eSize size)"""
        return _enigma.eWidgetDesktop_resize(self, size)


    def size(self):
        """size(eWidgetDesktop self) -> eSize"""
        return _enigma.eWidgetDesktop_size(self)


    def isDimmable(self):
        """isDimmable(eWidgetDesktop self) -> bool"""
        return _enigma.eWidgetDesktop_isDimmable(self)


    def createScreenshot(self, pm):
        """createScreenshot(eWidgetDesktop self, gPixmapPtr pm)"""
        return _enigma.eWidgetDesktop_createScreenshot(self, pm)


    def setFrameTime(self, ms):
        """setFrameTime(eWidgetDesktop self, int ms)"""
        return _enigma.eWidgetDesktop_setFrameTime(self, ms)


    def isAnimationsEnabled(self):
        """isAnimationsEnabled(eWidgetDesktop self) -> bool"""
        return _enigma.eWidgetDesktop_isAnimationsEnabled(self)


    def setAnimationsEnabled(self, enabled):
        """setAnimationsEnabled(eWidgetDesktop self, bool enabled)"""
        return _enigma.eWidgetDesktop_setAnimationsEnabled(self, enabled)


    def isWidgetAnimationsEnabled(self):
        """isWidgetAnimationsEnabled(eWidgetDesktop self) -> bool"""
        return _enigma.eWidgetDesktop_isWidgetAnimationsEnabled(self)


    def setWidgetAnimationsEnabled(self, enabled):
        """setWidgetAnimationsEnabled(eWidgetDesktop self, bool enabled)"""
        return _enigma.eWidgetDesktop_setWidgetAnimationsEnabled(self, enabled)


    def flags(self):
        """flags(eWidgetDesktop self) -> int"""
        return _enigma.eWidgetDesktop_flags(self)

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.requireNotify = new_instancemethod(_enigma.eWidgetDesktop_requireNotify, 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.get3dMode = new_instancemethod(_enigma.eWidgetDesktop_get3dMode, None, eWidgetDesktop)
eWidgetDesktop.set3dMode = new_instancemethod(_enigma.eWidgetDesktop_set3dMode, None, eWidgetDesktop)
eWidgetDesktop.set3dOffset = new_instancemethod(_enigma.eWidgetDesktop_set3dOffset, 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.setFrameTime = new_instancemethod(_enigma.eWidgetDesktop_setFrameTime, None, eWidgetDesktop)
eWidgetDesktop.isAnimationsEnabled = new_instancemethod(_enigma.eWidgetDesktop_isAnimationsEnabled, None, eWidgetDesktop)
eWidgetDesktop.setAnimationsEnabled = new_instancemethod(_enigma.eWidgetDesktop_setAnimationsEnabled, None, eWidgetDesktop)
eWidgetDesktop.isWidgetAnimationsEnabled = new_instancemethod(_enigma.eWidgetDesktop_isWidgetAnimationsEnabled, None, eWidgetDesktop)
eWidgetDesktop.setWidgetAnimationsEnabled = new_instancemethod(_enigma.eWidgetDesktop_setWidgetAnimationsEnabled, None, eWidgetDesktop)
eWidgetDesktop.flags = new_instancemethod(_enigma.eWidgetDesktop_flags, 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, parent, withActionMap=True):
        """
        __init__(eListbox self, eWidget parent, bool withActionMap=True) -> eListbox
        __init__(eListbox self, eWidget parent) -> eListbox
        """
        _enigma.eListbox_swiginit(self, _enigma.new_eListbox(parent, withActionMap))
    __swig_destroy__ = _enigma.delete_eListbox

    def setWrapAroundDefault(on):
        """setWrapAroundDefault(bool on)"""
        return _enigma.eListbox_setWrapAroundDefault(on)

    setWrapAroundDefault = staticmethod(setWrapAroundDefault)
    selectionChanged = _swig_property(_enigma.eListbox_selectionChanged_get, _enigma.eListbox_selectionChanged_set)
    layoutVertical = _enigma.eListbox_layoutVertical
    layoutHorizontal = _enigma.eListbox_layoutHorizontal
    layoutGrid = _enigma.eListbox_layoutGrid
    showOnDemand = _enigma.eListbox_showOnDemand
    showAlways = _enigma.eListbox_showAlways
    showNever = _enigma.eListbox_showNever

    def setScrollbarMode(self, mode):
        """setScrollbarMode(eListbox self, int mode)"""
        return _enigma.eListbox_setScrollbarMode(self, mode)


    def setupScrollbar(self):
        """setupScrollbar(eListbox self)"""
        return _enigma.eListbox_setupScrollbar(self)


    def setWrapAround(self, arg2):
        """setWrapAround(eListbox self, bool arg2)"""
        return _enigma.eListbox_setWrapAround(self, arg2)


    def setBacklogMode(self, arg2):
        """setBacklogMode(eListbox self, bool arg2)"""
        return _enigma.eListbox_setBacklogMode(self, arg2)


    def setContent(self, content):
        """setContent(eListbox self, iListboxContent content)"""
        return _enigma.eListbox_setContent(self, content)


    def getCurrentIndex(self):
        """getCurrentIndex(eListbox self) -> int"""
        return _enigma.eListbox_getCurrentIndex(self)


    def moveSelection(self, how):
        """moveSelection(eListbox self, long how)"""
        return _enigma.eListbox_moveSelection(self, how)


    def moveSelectionTo(self, index):
        """moveSelectionTo(eListbox self, int index)"""
        return _enigma.eListbox_moveSelectionTo(self, index)


    def moveToEnd(self):
        """moveToEnd(eListbox self)"""
        return _enigma.eListbox_moveToEnd(self)


    def atBegin(self):
        """atBegin(eListbox self) -> bool"""
        return _enigma.eListbox_atBegin(self)


    def atEnd(self):
        """atEnd(eListbox self) -> bool"""
        return _enigma.eListbox_atEnd(self)

    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
    refresh = _enigma.eListbox_refresh
    moveLeft = _enigma.eListbox_moveLeft
    moveRight = _enigma.eListbox_moveRight

    def setMode(self, mode):
        """setMode(eListbox self, int mode)"""
        return _enigma.eListbox_setMode(self, mode)


    def setItemHeight(self, h):
        """setItemHeight(eListbox self, int h)"""
        return _enigma.eListbox_setItemHeight(self, h)


    def setItemWidth(self, w):
        """setItemWidth(eListbox self, int w)"""
        return _enigma.eListbox_setItemWidth(self, w)


    def setMargin(self, margin):
        """setMargin(eListbox self, ePoint margin)"""
        return _enigma.eListbox_setMargin(self, margin)


    def setSelectionZoom(self, zoom):
        """setSelectionZoom(eListbox self, float zoom)"""
        return _enigma.eListbox_setSelectionZoom(self, zoom)


    def setSelectionEnable(self, en):
        """setSelectionEnable(eListbox self, int en)"""
        return _enigma.eListbox_setSelectionEnable(self, en)


    def setBackgroundColor(self, col):
        """setBackgroundColor(eListbox self, gRGB col)"""
        return _enigma.eListbox_setBackgroundColor(self, col)


    def setBackgroundColorSelected(self, col):
        """setBackgroundColorSelected(eListbox self, gRGB col)"""
        return _enigma.eListbox_setBackgroundColorSelected(self, col)


    def setForegroundColor(self, col):
        """setForegroundColor(eListbox self, gRGB col)"""
        return _enigma.eListbox_setForegroundColor(self, col)


    def setForegroundColorSelected(self, col):
        """setForegroundColorSelected(eListbox self, gRGB col)"""
        return _enigma.eListbox_setForegroundColorSelected(self, col)


    def setBackgroundPicture(self, pixmap):
        """setBackgroundPicture(eListbox self, gPixmapPtr pixmap)"""
        return _enigma.eListbox_setBackgroundPicture(self, pixmap)


    def setSelectionPicture(self, pixmap):
        """setSelectionPicture(eListbox self, gPixmapPtr pixmap)"""
        return _enigma.eListbox_setSelectionPicture(self, pixmap)


    def setScrollbarSliderPicture(self, pm):
        """setScrollbarSliderPicture(eListbox self, gPixmapPtr pm)"""
        return _enigma.eListbox_setScrollbarSliderPicture(self, pm)


    def setScrollbarSliderBackgroundPicture(self, pm):
        """setScrollbarSliderBackgroundPicture(eListbox self, gPixmapPtr pm)"""
        return _enigma.eListbox_setScrollbarSliderBackgroundPicture(self, pm)


    def setScrollbarValuePicture(self, pm):
        """setScrollbarValuePicture(eListbox self, gPixmapPtr pm)"""
        return _enigma.eListbox_setScrollbarValuePicture(self, pm)


    def setScrollbarSliderBorderWidth(self, size):
        """setScrollbarSliderBorderWidth(eListbox self, int size)"""
        return _enigma.eListbox_setScrollbarSliderBorderWidth(self, size)


    def setScrollbarWidth(self, size):
        """setScrollbarWidth(eListbox self, int size)"""
        return _enigma.eListbox_setScrollbarWidth(self, size)


    def setScrollbarBackgroundPixmapTopHeight(self, value):
        """setScrollbarBackgroundPixmapTopHeight(eListbox self, int value)"""
        return _enigma.eListbox_setScrollbarBackgroundPixmapTopHeight(self, value)


    def setScrollbarBackgroundPixmapBottomHeight(self, value):
        """setScrollbarBackgroundPixmapBottomHeight(eListbox self, int value)"""
        return _enigma.eListbox_setScrollbarBackgroundPixmapBottomHeight(self, value)


    def setScrollbarValuePixmapTopHeight(self, value):
        """setScrollbarValuePixmapTopHeight(eListbox self, int value)"""
        return _enigma.eListbox_setScrollbarValuePixmapTopHeight(self, value)


    def setScrollbarValuePixmapBottomHeight(self, value):
        """setScrollbarValuePixmapBottomHeight(eListbox self, int value)"""
        return _enigma.eListbox_setScrollbarValuePixmapBottomHeight(self, value)


    def resetScrollbarProperties(self):
        """resetScrollbarProperties(eListbox self)"""
        return _enigma.eListbox_resetScrollbarProperties(self)


    def getEntryTop(self):
        """getEntryTop(eListbox self) -> int"""
        return _enigma.eListbox_getEntryTop(self)


    def getVisibleItemCount(self):
        """getVisibleItemCount(eListbox self) -> int"""
        return _enigma.eListbox_getVisibleItemCount(self)


    def getSelectionRect(self, zoomed=False):
        """
        getSelectionRect(eListbox self, bool zoomed=False) -> eRect
        getSelectionRect(eListbox self) -> eRect
        """
        return _enigma.eListbox_getSelectionRect(self, zoomed)


    def itemHeight(self):
        """itemHeight(eListbox self) -> int"""
        return _enigma.eListbox_itemHeight(self)


    def itemWidth(self):
        """itemWidth(eListbox self) -> int"""
        return _enigma.eListbox_itemWidth(self)


    def currentPage(self):
        """currentPage(eListbox self) -> int"""
        return _enigma.eListbox_currentPage(self)


    def totalPages(self):
        """totalPages(eListbox self) -> int"""
        return _enigma.eListbox_totalPages(self)

eListbox.setScrollbarMode = new_instancemethod(_enigma.eListbox_setScrollbarMode, None, eListbox)
eListbox.setupScrollbar = new_instancemethod(_enigma.eListbox_setupScrollbar, 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.setMode = new_instancemethod(_enigma.eListbox_setMode, None, eListbox)
eListbox.setItemHeight = new_instancemethod(_enigma.eListbox_setItemHeight, None, eListbox)
eListbox.setItemWidth = new_instancemethod(_enigma.eListbox_setItemWidth, None, eListbox)
eListbox.setMargin = new_instancemethod(_enigma.eListbox_setMargin, None, eListbox)
eListbox.setSelectionZoom = new_instancemethod(_enigma.eListbox_setSelectionZoom, 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.getEntryTop = new_instancemethod(_enigma.eListbox_getEntryTop, None, eListbox)
eListbox.getVisibleItemCount = new_instancemethod(_enigma.eListbox_getVisibleItemCount, None, eListbox)
eListbox.getSelectionRect = new_instancemethod(_enigma.eListbox_getSelectionRect, None, eListbox)
eListbox.itemHeight = new_instancemethod(_enigma.eListbox_itemHeight, None, eListbox)
eListbox.itemWidth = new_instancemethod(_enigma.eListbox_itemWidth, None, eListbox)
eListbox.currentPage = new_instancemethod(_enigma.eListbox_currentPage, None, eListbox)
eListbox.totalPages = new_instancemethod(_enigma.eListbox_totalPages, None, eListbox)
eListbox_swigregister = _enigma.eListbox_swigregister
eListbox_swigregister(eListbox)

def eListbox_setWrapAroundDefault(on):
    """eListbox_setWrapAroundDefault(bool on)"""
    return _enigma.eListbox_setWrapAroundDefault(on)

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):
        """
        __init__(eListboxPythonStringContent self, int default_item_height=0) -> eListboxPythonStringContent
        __init__(eListboxPythonStringContent self) -> eListboxPythonStringContent
        """
        _enigma.eListboxPythonStringContent_swiginit(self, _enigma.new_eListboxPythonStringContent(default_item_height))
    __swig_destroy__ = _enigma.delete_eListboxPythonStringContent

    def setItemHeight(height):
        """setItemHeight(int height)"""
        return _enigma.eListboxPythonStringContent_setItemHeight(height)

    setItemHeight = staticmethod(setItemHeight)

    def setFont(fnt):
        """setFont(gFont fnt)"""
        return _enigma.eListboxPythonStringContent_setFont(fnt)

    setFont = staticmethod(setFont)

    def setLeftOffset(offset):
        """setLeftOffset(int offset)"""
        return _enigma.eListboxPythonStringContent_setLeftOffset(offset)

    setLeftOffset = staticmethod(setLeftOffset)

    def setRightOffset(offset):
        """setRightOffset(int offset)"""
        return _enigma.eListboxPythonStringContent_setRightOffset(offset)

    setRightOffset = staticmethod(setRightOffset)

    def setList(self, list):
        """setList(eListboxPythonStringContent self, PyObject * list)"""
        return _enigma.eListboxPythonStringContent_setList(self, list)


    def getCurrentSelection(self):
        """getCurrentSelection(eListboxPythonStringContent self) -> PyObject *"""
        return _enigma.eListboxPythonStringContent_getCurrentSelection(self)


    def getCurrentSelectionIndex(self):
        """getCurrentSelectionIndex(eListboxPythonStringContent self) -> int"""
        return _enigma.eListboxPythonStringContent_getCurrentSelectionIndex(self)


    def invalidateEntry(self, index):
        """invalidateEntry(eListboxPythonStringContent self, int index)"""
        return _enigma.eListboxPythonStringContent_invalidateEntry(self, index)


    def invalidate(self):
        """invalidate(eListboxPythonStringContent self)"""
        return _enigma.eListboxPythonStringContent_invalidate(self)


    def getItemSize(self):
        """getItemSize(eListboxPythonStringContent self) -> eSize"""
        return _enigma.eListboxPythonStringContent_getItemSize(self)

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(height):
    """eListboxPythonStringContent_setItemHeight(int height)"""
    return _enigma.eListboxPythonStringContent_setItemHeight(height)

def eListboxPythonStringContent_setFont(fnt):
    """eListboxPythonStringContent_setFont(gFont fnt)"""
    return _enigma.eListboxPythonStringContent_setFont(fnt)

def eListboxPythonStringContent_setLeftOffset(offset):
    """eListboxPythonStringContent_setLeftOffset(int offset)"""
    return _enigma.eListboxPythonStringContent_setLeftOffset(offset)

def eListboxPythonStringContent_setRightOffset(offset):
    """eListboxPythonStringContent_setRightOffset(int offset)"""
    return _enigma.eListboxPythonStringContent_setRightOffset(offset)

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

    def setItemHeight(height):
        """setItemHeight(int height)"""
        return _enigma.eListboxPythonConfigContent_setItemHeight(height)

    setItemHeight = staticmethod(setItemHeight)

    def setValueFont(fnt):
        """setValueFont(gFont fnt)"""
        return _enigma.eListboxPythonConfigContent_setValueFont(fnt)

    setValueFont = staticmethod(setValueFont)

    def setDescriptionFont(fnt):
        """setDescriptionFont(gFont fnt)"""
        return _enigma.eListboxPythonConfigContent_setDescriptionFont(fnt)

    setDescriptionFont = staticmethod(setDescriptionFont)

    def __init__(self):
        """__init__(eListboxPythonConfigContent self) -> eListboxPythonConfigContent"""
        _enigma.eListboxPythonConfigContent_swiginit(self, _enigma.new_eListboxPythonConfigContent())

    def paint(self, painter, style, offset, selected):
        """paint(eListboxPythonConfigContent self, gPainter & painter, eWindowStyle & style, ePoint offset, int selected)"""
        return _enigma.eListboxPythonConfigContent_paint(self, painter, style, offset, selected)


    def setSeparation(self, sep):
        """setSeparation(eListboxPythonConfigContent self, int sep)"""
        return _enigma.eListboxPythonConfigContent_setSeparation(self, sep)


    def setSeperation(self, sep):
        """setSeperation(eListboxPythonConfigContent self, int sep)"""
        return _enigma.eListboxPythonConfigContent_setSeperation(self, sep)


    def setDividerHeight(self, height):
        """setDividerHeight(eListboxPythonConfigContent self, int height)"""
        return _enigma.eListboxPythonConfigContent_setDividerHeight(self, height)


    def currentCursorSelectable(self):
        """currentCursorSelectable(eListboxPythonConfigContent self) -> int"""
        return _enigma.eListboxPythonConfigContent_currentCursorSelectable(self)

    __swig_destroy__ = _enigma.delete_eListboxPythonConfigContent
eListboxPythonConfigContent.paint = new_instancemethod(_enigma.eListboxPythonConfigContent_paint, None, eListboxPythonConfigContent)
eListboxPythonConfigContent.setSeparation = new_instancemethod(_enigma.eListboxPythonConfigContent_setSeparation, None, eListboxPythonConfigContent)
eListboxPythonConfigContent.setSeperation = new_instancemethod(_enigma.eListboxPythonConfigContent_setSeperation, None, eListboxPythonConfigContent)
eListboxPythonConfigContent.setDividerHeight = new_instancemethod(_enigma.eListboxPythonConfigContent_setDividerHeight, None, eListboxPythonConfigContent)
eListboxPythonConfigContent.currentCursorSelectable = new_instancemethod(_enigma.eListboxPythonConfigContent_currentCursorSelectable, None, eListboxPythonConfigContent)
eListboxPythonConfigContent_swigregister = _enigma.eListboxPythonConfigContent_swigregister
eListboxPythonConfigContent_swigregister(eListboxPythonConfigContent)

def eListboxPythonConfigContent_setItemHeight(height):
    """eListboxPythonConfigContent_setItemHeight(int height)"""
    return _enigma.eListboxPythonConfigContent_setItemHeight(height)

def eListboxPythonConfigContent_setValueFont(fnt):
    """eListboxPythonConfigContent_setValueFont(gFont fnt)"""
    return _enigma.eListboxPythonConfigContent_setValueFont(fnt)

def eListboxPythonConfigContent_setDescriptionFont(fnt):
    """eListboxPythonConfigContent_setDescriptionFont(gFont fnt)"""
    return _enigma.eListboxPythonConfigContent_setDescriptionFont(fnt)

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):
        """__init__(eListboxPythonMultiContent self) -> eListboxPythonMultiContent"""
        _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
    TYPE_TEXT_ALPHABLEND = _enigma.eListboxPythonMultiContent_TYPE_TEXT_ALPHABLEND

    def paint(self, painter, style, offset, selected):
        """paint(eListboxPythonMultiContent self, gPainter & painter, eWindowStyle & style, ePoint offset, int selected)"""
        return _enigma.eListboxPythonMultiContent_paint(self, painter, style, offset, selected)


    def currentCursorSelectable(self):
        """currentCursorSelectable(eListboxPythonMultiContent self) -> int"""
        return _enigma.eListboxPythonMultiContent_currentCursorSelectable(self)


    def setList(self, list):
        """setList(eListboxPythonMultiContent self, PyObject * list)"""
        return _enigma.eListboxPythonMultiContent_setList(self, list)


    def setFont(self, fnt, font):
        """setFont(eListboxPythonMultiContent self, int fnt, gFont font)"""
        return _enigma.eListboxPythonMultiContent_setFont(self, fnt, font)


    def setBuildFunc(self, func, add_selected_param=False):
        """
        setBuildFunc(eListboxPythonMultiContent self, PyObject * func, bool add_selected_param=False)
        setBuildFunc(eListboxPythonMultiContent self, PyObject * func)
        """
        return _enigma.eListboxPythonMultiContent_setBuildFunc(self, func, add_selected_param)


    def setSelectableFunc(self, func):
        """setSelectableFunc(eListboxPythonMultiContent self, PyObject * func)"""
        return _enigma.eListboxPythonMultiContent_setSelectableFunc(self, func)


    def setItemHeight(self, height):
        """setItemHeight(eListboxPythonMultiContent self, int height)"""
        return _enigma.eListboxPythonMultiContent_setItemHeight(self, height)


    def setItemWidth(self, width):
        """setItemWidth(eListboxPythonMultiContent self, int width)"""
        return _enigma.eListboxPythonMultiContent_setItemWidth(self, width)


    def getItemWidth(self):
        """getItemWidth(eListboxPythonMultiContent self) -> int"""
        return _enigma.eListboxPythonMultiContent_getItemWidth(self)


    def setSelectionEnable(self, selectionenabled):
        """setSelectionEnable(eListboxPythonMultiContent self, int selectionenabled)"""
        return _enigma.eListboxPythonMultiContent_setSelectionEnable(self, selectionenabled)


    def moveSelection(self, direction):
        """moveSelection(eListboxPythonMultiContent self, int direction)"""
        return _enigma.eListboxPythonMultiContent_moveSelection(self, direction)


    def setSelectionClip(self, rect, update=False):
        """
        setSelectionClip(eListboxPythonMultiContent self, eRect rect, bool update=False)
        setSelectionClip(eListboxPythonMultiContent self, eRect rect)
        """
        return _enigma.eListboxPythonMultiContent_setSelectionClip(self, rect, update)


    def updateClip(self, arg2):
        """updateClip(eListboxPythonMultiContent self, gRegion & arg2)"""
        return _enigma.eListboxPythonMultiContent_updateClip(self, arg2)


    def entryRemoved(self, idx):
        """entryRemoved(eListboxPythonMultiContent self, int idx)"""
        return _enigma.eListboxPythonMultiContent_entryRemoved(self, idx)


    def setTemplate(self, tmplate):
        """setTemplate(eListboxPythonMultiContent self, PyObject * tmplate)"""
        return _enigma.eListboxPythonMultiContent_setTemplate(self, tmplate)


    def refresh(self):
        """refresh(eListboxPythonMultiContent self)"""
        return _enigma.eListboxPythonMultiContent_refresh(self)

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.setItemWidth = new_instancemethod(_enigma.eListboxPythonMultiContent_setItemWidth, None, eListboxPythonMultiContent)
eListboxPythonMultiContent.getItemWidth = new_instancemethod(_enigma.eListboxPythonMultiContent_getItemWidth, 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.refresh = new_instancemethod(_enigma.eListboxPythonMultiContent_refresh, 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
SCALE_NONE = _enigma.SCALE_NONE
SCALE_CENTER = _enigma.SCALE_CENTER
SCALE_ASPECT = _enigma.SCALE_ASPECT
SCALE_WIDTH = _enigma.SCALE_WIDTH
SCALE_HEIGHT = _enigma.SCALE_HEIGHT
SCALE_STRETCH = _enigma.SCALE_STRETCH
SCALE_FILL = _enigma.SCALE_FILL
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
    idTV = _enigma.eWindowStyle_ENUMS_idTV
    idDisplay = _enigma.eWindowStyle_ENUMS_idDisplay
    idDisplaySmall = _enigma.eWindowStyle_ENUMS_idDisplaySmall
    idDisplayMedium = _enigma.eWindowStyle_ENUMS_idDisplayMedium
    idScrollbarVertical = _enigma.eWindowStyle_ENUMS_idScrollbarVertical
    idScrollbarHorizontal = _enigma.eWindowStyle_ENUMS_idScrollbarHorizontal
    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

    def getColor(self, what, color):
        """getColor(eWindowStylePtr self, int what, gRGBA color) -> RESULT"""
        return _enigma.eWindowStylePtr_getColor(self, what, color)


    def getListFontSize(self, what):
        """getListFontSize(eWindowStylePtr self, int what) -> int"""
        return _enigma.eWindowStylePtr_getListFontSize(self, what)


    def getListFontFace(self, what):
        """getListFontFace(eWindowStylePtr self, int what) -> std::string const"""
        return _enigma.eWindowStylePtr_getListFontFace(self, what)

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.getListFontSize = new_instancemethod(_enigma.eWindowStylePtr_getListFontSize, None, eWindowStylePtr)
eWindowStylePtr.getListFontFace = new_instancemethod(_enigma.eWindowStylePtr_getListFontFace, 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):
        """__init__(eWindowStyleSkinned self) -> eWindowStyleSkinned"""
        _enigma.eWindowStyleSkinned_swiginit(self, _enigma.new_eWindowStyleSkinned())

    def setStyle(self, painter, what):
        """setStyle(eWindowStyleSkinned self, gPainter & painter, int what)"""
        return _enigma.eWindowStyleSkinned_setStyle(self, painter, what)

    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

    def setPixmap(self, bs, bp, pixmap):
        """setPixmap(eWindowStyleSkinned self, int bs, int bp, gPixmapPtr pixmap)"""
        return _enigma.eWindowStyleSkinned_setPixmap(self, bs, bp, pixmap)


    def setColorBorder(self, bs, bp, color, size):
        """setColorBorder(eWindowStyleSkinned self, int bs, int bp, gRGB color, int size)"""
        return _enigma.eWindowStyleSkinned_setColorBorder(self, bs, bp, color, size)

    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
    listFontBig = _enigma.eWindowStyleSkinned_listFontBig
    listFontMedium = _enigma.eWindowStyleSkinned_listFontMedium
    listFontSmall = _enigma.eWindowStyleSkinned_listFontSmall
    listFontSmaller = _enigma.eWindowStyleSkinned_listFontSmaller
    listFontBigger = _enigma.eWindowStyleSkinned_listFontBigger
    listFontKeyboard = _enigma.eWindowStyleSkinned_listFontKeyboard
    listFontMax = _enigma.eWindowStyleSkinned_listFontMax

    def setColor(self, what, back):
        """setColor(eWindowStyleSkinned self, int what, gRGBA back)"""
        return _enigma.eWindowStyleSkinned_setColor(self, what, back)


    def getColor(self, what, color):
        """getColor(eWindowStyleSkinned self, int what, gRGBA color) -> RESULT"""
        return _enigma.eWindowStyleSkinned_getColor(self, what, color)


    def setTitleOffset(self, offset):
        """setTitleOffset(eWindowStyleSkinned self, eSize offset)"""
        return _enigma.eWindowStyleSkinned_setTitleOffset(self, offset)


    def setTitleFont(self, fnt):
        """setTitleFont(eWindowStyleSkinned self, gFont fnt)"""
        return _enigma.eWindowStyleSkinned_setTitleFont(self, fnt)


    def setListFont(self, what, size, face):
        """setListFont(eWindowStyleSkinned self, int what, int size, std::string const & face)"""
        return _enigma.eWindowStyleSkinned_setListFont(self, what, size, face)


    def getListFontSize(self, what):
        """getListFontSize(eWindowStyleSkinned self, int what) -> int"""
        return _enigma.eWindowStyleSkinned_getListFontSize(self, what)


    def getListFontFace(self, what):
        """getListFontFace(eWindowStyleSkinned self, int what) -> std::string const"""
        return _enigma.eWindowStyleSkinned_getListFontFace(self, what)

    __swig_destroy__ = _enigma.delete_eWindowStyleSkinned
eWindowStyleSkinned.setStyle = new_instancemethod(_enigma.eWindowStyleSkinned_setStyle, None, eWindowStyleSkinned)
eWindowStyleSkinned.setPixmap = new_instancemethod(_enigma.eWindowStyleSkinned_setPixmap, None, eWindowStyleSkinned)
eWindowStyleSkinned.setColorBorder = new_instancemethod(_enigma.eWindowStyleSkinned_setColorBorder, 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.setListFont = new_instancemethod(_enigma.eWindowStyleSkinned_setListFont, None, eWindowStyleSkinned)
eWindowStyleSkinned.getListFontSize = new_instancemethod(_enigma.eWindowStyleSkinned_getListFontSize, None, eWindowStyleSkinned)
eWindowStyleSkinned.getListFontFace = new_instancemethod(_enigma.eWindowStyleSkinned_getListFontFace, 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):
        """__init__(eWindowStyleScrollbar self) -> eWindowStyleScrollbar"""
        _enigma.eWindowStyleScrollbar_swiginit(self, _enigma.new_eWindowStyleScrollbar())

    def getColor(self, what, color):
        """getColor(eWindowStyleScrollbar self, int what, gRGBA color) -> RESULT"""
        return _enigma.eWindowStyleScrollbar_getColor(self, what, color)


    def getListFontSize(self, what):
        """getListFontSize(eWindowStyleScrollbar self, int what) -> int"""
        return _enigma.eWindowStyleScrollbar_getListFontSize(self, what)


    def getListFontFace(self, what):
        """getListFontFace(eWindowStyleScrollbar self, int what) -> std::string const"""
        return _enigma.eWindowStyleScrollbar_getListFontFace(self, what)


    def setBackgroundPixmap(self, *args):
        """
        setBackgroundPixmap(eWindowStyleScrollbar self, gPixmap * pixmap)
        setBackgroundPixmap(eWindowStyleScrollbar self, gPixmapPtr pixmap)
        """
        return _enigma.eWindowStyleScrollbar_setBackgroundPixmap(self, *args)


    def setValuePixmap(self, *args):
        """
        setValuePixmap(eWindowStyleScrollbar self, gPixmap * pixmap)
        setValuePixmap(eWindowStyleScrollbar self, gPixmapPtr pixmap)
        """
        return _enigma.eWindowStyleScrollbar_setValuePixmap(self, *args)


    def setBackgroundPixmapTopHeight(self, value):
        """setBackgroundPixmapTopHeight(eWindowStyleScrollbar self, int value)"""
        return _enigma.eWindowStyleScrollbar_setBackgroundPixmapTopHeight(self, value)


    def setBackgroundPixmapBottomHeight(self, value):
        """setBackgroundPixmapBottomHeight(eWindowStyleScrollbar self, int value)"""
        return _enigma.eWindowStyleScrollbar_setBackgroundPixmapBottomHeight(self, value)


    def setValuePixmapTopHeight(self, value):
        """setValuePixmapTopHeight(eWindowStyleScrollbar self, int value)"""
        return _enigma.eWindowStyleScrollbar_setValuePixmapTopHeight(self, value)


    def setValuePixmapBottomHeight(self, value):
        """setValuePixmapBottomHeight(eWindowStyleScrollbar self, int value)"""
        return _enigma.eWindowStyleScrollbar_setValuePixmapBottomHeight(self, value)


    def setScrollbarWidth(self, value):
        """setScrollbarWidth(eWindowStyleScrollbar self, int value)"""
        return _enigma.eWindowStyleScrollbar_setScrollbarWidth(self, value)


    def setScrollbarBorderWidth(self, value):
        """setScrollbarBorderWidth(eWindowStyleScrollbar self, int value)"""
        return _enigma.eWindowStyleScrollbar_setScrollbarBorderWidth(self, value)

    __swig_destroy__ = _enigma.delete_eWindowStyleScrollbar
eWindowStyleScrollbar.getColor = new_instancemethod(_enigma.eWindowStyleScrollbar_getColor, None, eWindowStyleScrollbar)
eWindowStyleScrollbar.getListFontSize = new_instancemethod(_enigma.eWindowStyleScrollbar_getListFontSize, None, eWindowStyleScrollbar)
eWindowStyleScrollbar.getListFontFace = new_instancemethod(_enigma.eWindowStyleScrollbar_getListFontFace, 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, parent):
        """__init__(eVideoWidget self, eWidget parent) -> eVideoWidget"""
        _enigma.eVideoWidget_swiginit(self, _enigma.new_eVideoWidget(parent))
    __swig_destroy__ = _enigma.delete_eVideoWidget

    def setDecoder(self, target):
        """setDecoder(eVideoWidget self, int target)"""
        return _enigma.eVideoWidget_setDecoder(self, target)


    def setFBSize(self, size):
        """setFBSize(eVideoWidget self, eSize size)"""
        return _enigma.eVideoWidget_setFBSize(self, size)

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 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, parent):
        """__init__(eSubtitleWidget self, eWidget parent) -> eSubtitleWidget"""
        _enigma.eSubtitleWidget_swiginit(self, _enigma.new_eSubtitleWidget(parent))

    def setPage(self, *args):
        """
        setPage(eSubtitleWidget self, eDVBTeletextSubtitlePage const & p)
        setPage(eSubtitleWidget self, eDVBSubtitlePage const & p)
        setPage(eSubtitleWidget self, eTextSubtitlePage const & p)
        """
        return _enigma.eSubtitleWidget_setPage(self, *args)


    def clearPage(self):
        """clearPage(eSubtitleWidget self)"""
        return _enigma.eSubtitleWidget_clearPage(self)


    def setPixmap(self, *args):
        """
        setPixmap(eSubtitleWidget self, gPixmapPtr pixmap, gRegion changed, eRect dest)
        setPixmap(eSubtitleWidget self, gPixmapPtr pixmap, gRegion changed)
        """
        return _enigma.eSubtitleWidget_setPixmap(self, *args)


    def setFullscreenPixmap(self, pixmap, changed):
        """setFullscreenPixmap(eSubtitleWidget self, gPixmapPtr pixmap, gRegion changed)"""
        return _enigma.eSubtitleWidget_setFullscreenPixmap(self, pixmap, changed)

    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

    def setFontStyle(face, font, autoColor, col, shadowCol, shadowOffset):
        """setFontStyle(eSubtitleWidget::subfont_t face, gFont font, int autoColor, gRGB col, gRGB shadowCol, ePoint shadowOffset)"""
        return _enigma.eSubtitleWidget_setFontStyle(face, font, autoColor, col, shadowCol, shadowOffset)

    setFontStyle = staticmethod(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.setFullscreenPixmap = new_instancemethod(_enigma.eSubtitleWidget_setFullscreenPixmap, None, eSubtitleWidget)
eSubtitleWidget_swigregister = _enigma.eSubtitleWidget_swigregister
eSubtitleWidget_swigregister(eSubtitleWidget)

def eSubtitleWidget_setFontStyle(face, font, autoColor, col, shadowCol, shadowOffset):
    """eSubtitleWidget_setFontStyle(eSubtitleWidget::subfont_t face, gFont font, int autoColor, gRGB col, gRGB shadowCol, ePoint shadowOffset)"""
    return _enigma.eSubtitleWidget_setFontStyle(face, font, autoColor, col, shadowCol, shadowOffset)

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):
        """__init__(Teletext self) -> Teletext"""
        _enigma.Teletext_swiginit(self, _enigma.new_Teletext())

    def show(self, *args):
        """
        show(Teletext self, eWidget parent, ePoint position, eSize size)
        show(Teletext self, eWidget parent, ePoint position)
        show(Teletext self, eWidget parent)
        """
        return _enigma.Teletext_show(self, *args)


    def hide(self):
        """hide(Teletext self)"""
        return _enigma.Teletext_hide(self)


    def update(self, *args):
        """
        update(Teletext self, int x, int y, int width, int height, Teletext::text_mode_t mode, scalefilter_t scalefilter)
        update(Teletext self, int x, int y, int width, int height, Teletext::text_mode_t mode)
        update(Teletext self, int x, int y, int width, int height)
        """
        return _enigma.Teletext_update(self, *args)


    def getRenderBufferOffset(self):
        """getRenderBufferOffset(Teletext self) -> unsigned int"""
        return _enigma.Teletext_getRenderBufferOffset(self)


    def getRenderBufferStride(self):
        """getRenderBufferStride(Teletext self) -> unsigned short"""
        return _enigma.Teletext_getRenderBufferStride(self)


    def getRenderBufferFD(self):
        """getRenderBufferFD(Teletext self) -> int"""
        return _enigma.Teletext_getRenderBufferFD(self)


    def getTextPidsAndName(self, root):
        """getTextPidsAndName(Teletext self, eServiceReference root) -> std::list< std::tuple< std::string,std::string,int >,std::allocator< std::tuple< std::string,std::string,int > > >"""
        return _enigma.Teletext_getTextPidsAndName(self, root)

    __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.getRenderBufferFD = new_instancemethod(_enigma.Teletext_getRenderBufferFD, 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):
        """__init__(eListboxServiceContent self) -> eListboxServiceContent"""
        _enigma.eListboxServiceContent_swiginit(self, _enigma.new_eListboxServiceContent())

    def addService(self, ref, beforeCurrent=False):
        """
        addService(eListboxServiceContent self, eServiceReference ref, bool beforeCurrent=False)
        addService(eListboxServiceContent self, eServiceReference ref)
        """
        return _enigma.eListboxServiceContent_addService(self, ref, beforeCurrent)


    def removeCurrent(self):
        """removeCurrent(eListboxServiceContent self)"""
        return _enigma.eListboxServiceContent_removeCurrent(self)


    def FillFinished(self):
        """FillFinished(eListboxServiceContent self)"""
        return _enigma.eListboxServiceContent_FillFinished(self)


    def setRoot(self, ref, justSet=False):
        """
        setRoot(eListboxServiceContent self, eServiceReference ref, bool justSet=False)
        setRoot(eListboxServiceContent self, eServiceReference ref)
        """
        return _enigma.eListboxServiceContent_setRoot(self, ref, justSet)


    def getCurrent(self, ref):
        """getCurrent(eListboxServiceContent self, eServiceReference ref)"""
        return _enigma.eListboxServiceContent_getCurrent(self, ref)


    def getNextBeginningWithChar(self, c):
        """getNextBeginningWithChar(eListboxServiceContent self, char c) -> int"""
        return _enigma.eListboxServiceContent_getNextBeginningWithChar(self, c)


    def getPrevMarkerPos(self):
        """getPrevMarkerPos(eListboxServiceContent self) -> int"""
        return _enigma.eListboxServiceContent_getPrevMarkerPos(self)


    def getNextMarkerPos(self):
        """getNextMarkerPos(eListboxServiceContent self) -> int"""
        return _enigma.eListboxServiceContent_getNextMarkerPos(self)


    def initMarked(self):
        """initMarked(eListboxServiceContent self)"""
        return _enigma.eListboxServiceContent_initMarked(self)


    def addMarked(self, ref):
        """addMarked(eListboxServiceContent self, eServiceReference ref)"""
        return _enigma.eListboxServiceContent_addMarked(self, ref)


    def removeMarked(self, ref):
        """removeMarked(eListboxServiceContent self, eServiceReference ref)"""
        return _enigma.eListboxServiceContent_removeMarked(self, ref)


    def isMarked(self, ref):
        """isMarked(eListboxServiceContent self, eServiceReference ref) -> int"""
        return _enigma.eListboxServiceContent_isMarked(self, ref)


    def markedQueryStart(self):
        """markedQueryStart(eListboxServiceContent self)"""
        return _enigma.eListboxServiceContent_markedQueryStart(self)


    def markedQueryNext(self, ref):
        """markedQueryNext(eListboxServiceContent self, eServiceReference ref) -> int"""
        return _enigma.eListboxServiceContent_markedQueryNext(self, ref)


    def lookupService(self, ref):
        """lookupService(eListboxServiceContent self, eServiceReference ref) -> int"""
        return _enigma.eListboxServiceContent_lookupService(self, ref)


    def setCurrent(self, ref):
        """setCurrent(eListboxServiceContent self, eServiceReference ref)"""
        return _enigma.eListboxServiceContent_setCurrent(self, ref)


    def sort(self):
        """sort(eListboxServiceContent self)"""
        return _enigma.eListboxServiceContent_sort(self)


    def setCurrentMarked(self, arg2):
        """setCurrentMarked(eListboxServiceContent self, bool arg2) -> int"""
        return _enigma.eListboxServiceContent_setCurrentMarked(self, arg2)


    def isCurrentMarked(self):
        """isCurrentMarked(eListboxServiceContent self) -> bool"""
        return _enigma.eListboxServiceContent_isCurrentMarked(self)


    def getNumMarkersBeforeCurrent(self):
        """getNumMarkersBeforeCurrent(eListboxServiceContent self) -> int"""
        return _enigma.eListboxServiceContent_getNumMarkersBeforeCurrent(self)

    __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):
        """__init__(pNavigation self) -> pNavigation"""
        _enigma.pNavigation_swiginit(self, _enigma.new_pNavigation())

    def playService(self, service):
        """playService(pNavigation self, eServiceReference service) -> RESULT"""
        return _enigma.pNavigation_playService(self, service)


    def stopService(self):
        """stopService(pNavigation self) -> RESULT"""
        return _enigma.pNavigation_stopService(self)


    def pause(self, p):
        """pause(pNavigation self, int p) -> RESULT"""
        return _enigma.pNavigation_pause(self, p)


    def getCurrentService(self):
        """getCurrentService(pNavigation self)"""
        return _enigma.pNavigation_getCurrentService(self)


    def getCurrentServiceReference(self):
        """getCurrentServiceReference(pNavigation self)"""
        return _enigma.pNavigation_getCurrentServiceReference(self)


    def recordService(self, ref, simulate):
        """recordService(pNavigation self, eServiceReference ref, bool simulate)"""
        return _enigma.pNavigation_recordService(self, ref, simulate)


    def stopRecordService(self, service):
        """stopRecordService(pNavigation self, iRecordableServicePtr service) -> RESULT"""
        return _enigma.pNavigation_stopRecordService(self, service)


    def getRecordings(self, simulate=False):
        """
        getRecordings(pNavigation self, bool simulate=False) -> std::list< ePtr< iRecordableService >,std::allocator< ePtr< iRecordableService > > >
        getRecordings(pNavigation self) -> std::list< ePtr< iRecordableService >,std::allocator< ePtr< iRecordableService > > >
        """
        return _enigma.pNavigation_getRecordings(self, simulate)


    def getInstance():
        """getInstance() -> pNavigation"""
        return _enigma.pNavigation_getInstance()

    getInstance = staticmethod(getInstance)
    __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.getCurrentServiceReference = new_instancemethod(_enigma.pNavigation_getCurrentServiceReference, 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)

def pNavigation_getInstance():
    """pNavigation_getInstance() -> pNavigation"""
    return _enigma.pNavigation_getInstance()

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.bindKeyDevice = new_instancemethod(_enigma.eActionMap_bindKeyDevice, None, eActionMap)
eActionMap.unbindKeyDevice = new_instancemethod(_enigma.eActionMap_unbindKeyDevice, 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):
        """
        __init__(gFont self, std::string const & family, int pointSize) -> gFont
        __init__(gFont self) -> gFont
        """
        _enigma.gFont_swiginit(self, _enigma.new_gFont(*args))
gFont_swigregister = _enigma.gFont_swigregister
gFont_swigregister(gFont)


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

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 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_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.setLNBTunerInput = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBTunerInput, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBTunerInput = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBTunerInput, 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.setDegreePerSecond = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setDegreePerSecond, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSatCR = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSatCR, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSatCRvco = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSatCRvco, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSatCRpin = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSatCRpin, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSatCRpositions = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSatCRpositions, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBSatCRmode = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBSatCRmode, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBSatCR = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBSatCR, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBSatCRvco = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBSatCRvco, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBSatCRpin = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBSatCRpin, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBSatCRpositions = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBSatCRpositions, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.getLNBSatCRmode = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getLNBSatCRmode, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setLNBPowerOnDelay = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setLNBPowerOnDelay, 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.getBandCutOffFrequency = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_getBandCutOffFrequency, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.setRotorMoving = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_setRotorMoving, None, eDVBSatelliteEquipmentControl)
eDVBSatelliteEquipmentControl.isRotorMoving = new_instancemethod(_enigma.eDVBSatelliteEquipmentControl_isRotorMoving, 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(param, value):
    return _enigma.eDVBSatelliteEquipmentControl_setParam(param, value)
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
    load_finished = _enigma.cachestate_load_finished
    save_finished = _enigma.cachestate_save_finished
    __swig_destroy__ = _enigma.delete_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
    EXACT_TITLE_SEARCH = _enigma.eEPGCache_EXACT_TITLE_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
    PARTIAL_EXTENDED_DESCRIPTION_SEARCH = _enigma.eEPGCache_PARTIAL_EXTENDED_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.applyDbBugfix20161008 = new_instancemethod(_enigma.eEPGCache_applyDbBugfix20161008, None, eEPGCache)
eEPGCache.createUpdateTriggers = new_instancemethod(_enigma.eEPGCache_createUpdateTriggers, 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(text):
    return _enigma.eEPGCache_getStringHash(text)
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_6_7 = _enigma.eDVBFrontendParametersSatellite_FEC_6_7
    FEC_None = _enigma.eDVBFrontendParametersSatellite_FEC_None
    System_DVB_S = _enigma.eDVBFrontendParametersSatellite_System_DVB_S
    System_DVB_S2 = _enigma.eDVBFrontendParametersSatellite_System_DVB_S2
    System_DVB_S_S2 = _enigma.eDVBFrontendParametersSatellite_System_DVB_S_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
    Modulation_16APSK = _enigma.eDVBFrontendParametersSatellite_Modulation_16APSK
    Modulation_32APSK = _enigma.eDVBFrontendParametersSatellite_Modulation_32APSK
    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
    PLS_Root = _enigma.eDVBFrontendParametersSatellite_PLS_Root
    PLS_Gold = _enigma.eDVBFrontendParametersSatellite_PLS_Gold
    PLS_Combo = _enigma.eDVBFrontendParametersSatellite_PLS_Combo
    PLS_Unknown = _enigma.eDVBFrontendParametersSatellite_PLS_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)
    is_id = _swig_property(_enigma.eDVBFrontendParametersSatellite_is_id_get, _enigma.eDVBFrontendParametersSatellite_is_id_set)
    pls_mode = _swig_property(_enigma.eDVBFrontendParametersSatellite_pls_mode_get, _enigma.eDVBFrontendParametersSatellite_pls_mode_set)
    pls_code = _swig_property(_enigma.eDVBFrontendParametersSatellite_pls_code_get, _enigma.eDVBFrontendParametersSatellite_pls_code_set)

    def __init__(self):
        """__init__(eDVBFrontendParametersSatellite self) -> eDVBFrontendParametersSatellite"""
        _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):
        """__init__(eDVBFrontendParametersCable self) -> eDVBFrontendParametersCable"""
        _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
    Bandwidth_5MHz = _enigma.eDVBFrontendParametersTerrestrial_Bandwidth_5MHz
    Bandwidth_1_712MHz = _enigma.eDVBFrontendParametersTerrestrial_Bandwidth_1_712MHz
    Bandwidth_10MHz = _enigma.eDVBFrontendParametersTerrestrial_Bandwidth_10MHz
    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
    FEC_6_7 = _enigma.eDVBFrontendParametersTerrestrial_FEC_6_7
    FEC_8_9 = _enigma.eDVBFrontendParametersTerrestrial_FEC_8_9
    FEC_3_5 = _enigma.eDVBFrontendParametersTerrestrial_FEC_3_5
    FEC_4_5 = _enigma.eDVBFrontendParametersTerrestrial_FEC_4_5
    TransmissionMode_2k = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_2k
    TransmissionMode_8k = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_8k
    TransmissionMode_Auto = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_Auto
    TransmissionMode_4k = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_4k
    TransmissionMode_1k = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_1k
    TransmissionMode_16k = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_16k
    TransmissionMode_32k = _enigma.eDVBFrontendParametersTerrestrial_TransmissionMode_32k
    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
    GuardInterval_1_128 = _enigma.eDVBFrontendParametersTerrestrial_GuardInterval_1_128
    GuardInterval_19_128 = _enigma.eDVBFrontendParametersTerrestrial_GuardInterval_19_128
    GuardInterval_19_256 = _enigma.eDVBFrontendParametersTerrestrial_GuardInterval_19_256
    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
    Modulation_QAM256 = _enigma.eDVBFrontendParametersTerrestrial_Modulation_QAM256
    Inversion_Off = _enigma.eDVBFrontendParametersTerrestrial_Inversion_Off
    Inversion_On = _enigma.eDVBFrontendParametersTerrestrial_Inversion_On
    Inversion_Unknown = _enigma.eDVBFrontendParametersTerrestrial_Inversion_Unknown
    System_DVB_T = _enigma.eDVBFrontendParametersTerrestrial_System_DVB_T
    System_DVB_T2 = _enigma.eDVBFrontendParametersTerrestrial_System_DVB_T2
    System_DVB_T_T2 = _enigma.eDVBFrontendParametersTerrestrial_System_DVB_T_T2
    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)
    system = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_system_get, _enigma.eDVBFrontendParametersTerrestrial_system_set)
    plp_id = _swig_property(_enigma.eDVBFrontendParametersTerrestrial_plp_id_get, _enigma.eDVBFrontendParametersTerrestrial_plp_id_set)

    def __init__(self):
        """__init__(eDVBFrontendParametersTerrestrial self) -> eDVBFrontendParametersTerrestrial"""
        _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):
        """__init__(eDVBDiseqcCommand self) -> eDVBDiseqcCommand"""
        _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
    feTerrestrial2 = _enigma.iDVBFrontend_ENUMS_feTerrestrial2
    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
    statePendingClose = _enigma.iDVBFrontend_ENUMS_statePendingClose
    stateClosed = _enigma.iDVBFrontend_ENUMS_stateClosed
    toneOff = _enigma.iDVBFrontend_ENUMS_toneOff
    toneOn = _enigma.iDVBFrontend_ENUMS_toneOn
    toneUnknown = _enigma.iDVBFrontend_ENUMS_toneUnknown
    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
    uncorrBlocks = _enigma.iDVBFrontend_ENUMS_uncorrBlocks
    canDVBS2Multistream = _enigma.iDVBFrontend_ENUMS_canDVBS2Multistream
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.getTunedType = new_instancemethod(_enigma.iDVBFrontendPtr_getTunedType, 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.getCapabilities = new_instancemethod(_enigma.iDVBFrontendPtr_getCapabilities, 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)
    frontendInputUseMaskChanged = _swig_property(_enigma.eDVBResourceManager_frontendInputUseMaskChanged_get, _enigma.eDVBResourceManager_frontendInputUseMaskChanged_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.getFrontendCapabilities = new_instancemethod(_enigma.eDVBResourceManager_getFrontendCapabilities, 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)
    setTrueHDSupport = staticmethod(_enigma.eDVBServicePMTHandler_setTrueHDSupport)
    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(b):
    return _enigma.eDVBServicePMTHandler_setDDPSupport(b)
eDVBServicePMTHandler_setDDPSupport = _enigma.eDVBServicePMTHandler_setDDPSupport

def eDVBServicePMTHandler_setTrueHDSupport(b):
    return _enigma.eDVBServicePMTHandler_setTrueHDSupport(b)
eDVBServicePMTHandler_setTrueHDSupport = _enigma.eDVBServicePMTHandler_setTrueHDSupport

class eDBusInterfaceProxy(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):
        """__init__(eDBusInterfaceProxy self) -> eDBusInterfaceProxy"""
        if self.__class__ == eDBusInterfaceProxy:
            _self = None
        else:
            _self = self
        _enigma.eDBusInterfaceProxy_swiginit(self, _enigma.new_eDBusInterfaceProxy(_self, ))
    __swig_destroy__ = _enigma.delete_eDBusInterfaceProxy

    def isTimerPending(self):
        """isTimerPending(eDBusInterfaceProxy self) -> bool"""
        return _enigma.eDBusInterfaceProxy_isTimerPending(self)


    def play(self, val, isUri):
        """play(eDBusInterfaceProxy self, std::string const & val, bool isUri) -> bool"""
        return _enigma.eDBusInterfaceProxy_play(self, val, isUri)


    def pause(self):
        """pause(eDBusInterfaceProxy self) -> bool"""
        return _enigma.eDBusInterfaceProxy_pause(self)


    def resume(self):
        """resume(eDBusInterfaceProxy self) -> bool"""
        return _enigma.eDBusInterfaceProxy_resume(self)


    def stop(self):
        """stop(eDBusInterfaceProxy self) -> bool"""
        return _enigma.eDBusInterfaceProxy_stop(self)


    def setVolume(self, to):
        """setVolume(eDBusInterfaceProxy self, int to) -> bool"""
        return _enigma.eDBusInterfaceProxy_setVolume(self, to)


    def getVolume(self):
        """getVolume(eDBusInterfaceProxy self) -> int"""
        return _enigma.eDBusInterfaceProxy_getVolume(self)

    def __disown__(self):
        self.this.disown()
        _enigma.disown_eDBusInterfaceProxy(self)
        return weakref_proxy(self)
eDBusInterfaceProxy.isTimerPending = new_instancemethod(_enigma.eDBusInterfaceProxy_isTimerPending, None, eDBusInterfaceProxy)
eDBusInterfaceProxy.play = new_instancemethod(_enigma.eDBusInterfaceProxy_play, None, eDBusInterfaceProxy)
eDBusInterfaceProxy.pause = new_instancemethod(_enigma.eDBusInterfaceProxy_pause, None, eDBusInterfaceProxy)
eDBusInterfaceProxy.resume = new_instancemethod(_enigma.eDBusInterfaceProxy_resume, None, eDBusInterfaceProxy)
eDBusInterfaceProxy.stop = new_instancemethod(_enigma.eDBusInterfaceProxy_stop, None, eDBusInterfaceProxy)
eDBusInterfaceProxy.setVolume = new_instancemethod(_enigma.eDBusInterfaceProxy_setVolume, None, eDBusInterfaceProxy)
eDBusInterfaceProxy.getVolume = new_instancemethod(_enigma.eDBusInterfaceProxy_getVolume, None, eDBusInterfaceProxy)
eDBusInterfaceProxy_swigregister = _enigma.eDBusInterfaceProxy_swigregister
eDBusInterfaceProxy_swigregister(eDBusInterfaceProxy)

class eDBusInterface(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
    STREAM_STATE_STOPPED = _enigma.eDBusInterface_STREAM_STATE_STOPPED
    STREAM_STATE_PLAYING = _enigma.eDBusInterface_STREAM_STATE_PLAYING
    STREAM_STATE_PAUSED = _enigma.eDBusInterface_STREAM_STATE_PAUSED
    STREAM_STATE_BUFFERING = _enigma.eDBusInterface_STREAM_STATE_BUFFERING
    STREAM_STATE_SEEKING = _enigma.eDBusInterface_STREAM_STATE_SEEKING

    def setProxy(proxy):
        """setProxy(eDBusInterfaceProxy proxy) -> bool"""
        return _enigma.eDBusInterface_setProxy(proxy)

    setProxy = staticmethod(setProxy)

    def sendEvent(id):
        """sendEvent(int id)"""
        return _enigma.eDBusInterface_sendEvent(id)

    sendEvent = staticmethod(sendEvent)
eDBusInterface_swigregister = _enigma.eDBusInterface_swigregister
eDBusInterface_swigregister(eDBusInterface)

def eDBusInterface_setProxy(proxy):
    """eDBusInterface_setProxy(eDBusInterfaceProxy proxy) -> bool"""
    return _enigma.eDBusInterface_setProxy(proxy)

def eDBusInterface_sendEvent(id):
    """eDBusInterface_sendEvent(int id)"""
    return _enigma.eDBusInterface_sendEvent(id)

class eWebMediaPlayerProxy(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):
        """__init__(eWebMediaPlayerProxy self) -> eWebMediaPlayerProxy"""
        if self.__class__ == eWebMediaPlayerProxy:
            _self = None
        else:
            _self = self
        _enigma.eWebMediaPlayerProxy_swiginit(self, _enigma.new_eWebMediaPlayerProxy(_self, ))
    __swig_destroy__ = _enigma.delete_eWebMediaPlayerProxy

    def setVideoWindow(self, x, y, width, height):
        """setVideoWindow(eWebMediaPlayerProxy self, int x, int y, int width, int height)"""
        return _enigma.eWebMediaPlayerProxy_setVideoWindow(self, x, y, width, height)


    def play(self, val, isUri):
        """play(eWebMediaPlayerProxy self, std::string const & val, bool isUri) -> bool"""
        return _enigma.eWebMediaPlayerProxy_play(self, val, isUri)


    def pause(self):
        """pause(eWebMediaPlayerProxy self) -> bool"""
        return _enigma.eWebMediaPlayerProxy_pause(self)


    def resume(self):
        """resume(eWebMediaPlayerProxy self) -> bool"""
        return _enigma.eWebMediaPlayerProxy_resume(self)


    def stop(self):
        """stop(eWebMediaPlayerProxy self) -> bool"""
        return _enigma.eWebMediaPlayerProxy_stop(self)


    def setVolume(self, to):
        """setVolume(eWebMediaPlayerProxy self, int to) -> bool"""
        return _enigma.eWebMediaPlayerProxy_setVolume(self, to)


    def getVolume(self):
        """getVolume(eWebMediaPlayerProxy self) -> int"""
        return _enigma.eWebMediaPlayerProxy_getVolume(self)

    def __disown__(self):
        self.this.disown()
        _enigma.disown_eWebMediaPlayerProxy(self)
        return weakref_proxy(self)
eWebMediaPlayerProxy.setVideoWindow = new_instancemethod(_enigma.eWebMediaPlayerProxy_setVideoWindow, None, eWebMediaPlayerProxy)
eWebMediaPlayerProxy.play = new_instancemethod(_enigma.eWebMediaPlayerProxy_play, None, eWebMediaPlayerProxy)
eWebMediaPlayerProxy.pause = new_instancemethod(_enigma.eWebMediaPlayerProxy_pause, None, eWebMediaPlayerProxy)
eWebMediaPlayerProxy.resume = new_instancemethod(_enigma.eWebMediaPlayerProxy_resume, None, eWebMediaPlayerProxy)
eWebMediaPlayerProxy.stop = new_instancemethod(_enigma.eWebMediaPlayerProxy_stop, None, eWebMediaPlayerProxy)
eWebMediaPlayerProxy.setVolume = new_instancemethod(_enigma.eWebMediaPlayerProxy_setVolume, None, eWebMediaPlayerProxy)
eWebMediaPlayerProxy.getVolume = new_instancemethod(_enigma.eWebMediaPlayerProxy_getVolume, None, eWebMediaPlayerProxy)
eWebMediaPlayerProxy_swigregister = _enigma.eWebMediaPlayerProxy_swigregister
eWebMediaPlayerProxy_swigregister(eWebMediaPlayerProxy)

class eWebMediaPlayer(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
    STREAM_STATE_STOPPED = _enigma.eWebMediaPlayer_STREAM_STATE_STOPPED
    STREAM_STATE_PLAYING = _enigma.eWebMediaPlayer_STREAM_STATE_PLAYING
    STREAM_STATE_PAUSED = _enigma.eWebMediaPlayer_STREAM_STATE_PAUSED
    STREAM_STATE_BUFFERING = _enigma.eWebMediaPlayer_STREAM_STATE_BUFFERING
    STREAM_STATE_SEEKING = _enigma.eWebMediaPlayer_STREAM_STATE_SEEKING
    STREAM_STATE_ERROR = _enigma.eWebMediaPlayer_STREAM_STATE_ERROR
    STREAM_STATE_CANCELLED = _enigma.eWebMediaPlayer_STREAM_STATE_CANCELLED
    STREAM_POSITION_CHANGED = _enigma.eWebMediaPlayer_STREAM_POSITION_CHANGED
    STREAM_RESOLUTION_CHANGED = _enigma.eWebMediaPlayer_STREAM_RESOLUTION_CHANGED

    def setProxy(proxy):
        """setProxy(eWebMediaPlayerProxy proxy) -> bool"""
        return _enigma.eWebMediaPlayer_setProxy(proxy)

    setProxy = staticmethod(setProxy)

    def resetProxy():
        """resetProxy()"""
        return _enigma.eWebMediaPlayer_resetProxy()

    resetProxy = staticmethod(resetProxy)

    def sendEvent(id):
        """sendEvent(int id)"""
        return _enigma.eWebMediaPlayer_sendEvent(id)

    sendEvent = staticmethod(sendEvent)
eWebMediaPlayer_swigregister = _enigma.eWebMediaPlayer_swigregister
eWebMediaPlayer_swigregister(eWebMediaPlayer)

def eWebMediaPlayer_setProxy(proxy):
    """eWebMediaPlayer_setProxy(eWebMediaPlayerProxy proxy) -> bool"""
    return _enigma.eWebMediaPlayer_setProxy(proxy)

def eWebMediaPlayer_resetProxy():
    """eWebMediaPlayer_resetProxy()"""
    return _enigma.eWebMediaPlayer_resetProxy()

def eWebMediaPlayer_sendEvent(id):
    """eWebMediaPlayer_sendEvent(int id)"""
    return _enigma.eWebMediaPlayer_sendEvent(id)

class eInputDeviceManager(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
    FEATURE_UNCONNECTED_KEYPRESS = _enigma.eInputDeviceManager_FEATURE_UNCONNECTED_KEYPRESS

    def getInstance():
        """getInstance() -> eInputDeviceManager"""
        return _enigma.eInputDeviceManager_getInstance()

    getInstance = staticmethod(getInstance)

    def start(self):
        """start(eInputDeviceManager self)"""
        return _enigma.eInputDeviceManager_start(self)


    def stop(self):
        """stop(eInputDeviceManager self)"""
        return _enigma.eInputDeviceManager_stop(self)


    def hasFeature(self, feature):
        """hasFeature(eInputDeviceManager self, int feature) -> bool"""
        return _enigma.eInputDeviceManager_hasFeature(self, feature)


    def available(self):
        """available(eInputDeviceManager self) -> bool"""
        return _enigma.eInputDeviceManager_available(self)


    def responding(self):
        """responding(eInputDeviceManager self) -> bool"""
        return _enigma.eInputDeviceManager_responding(self)


    def version(self):
        """version(eInputDeviceManager self) -> std::string"""
        return _enigma.eInputDeviceManager_version(self)


    def getDevice(self, address):
        """getDevice(eInputDeviceManager self, std::string const & address) -> eManagedInputDevicePtr"""
        return _enigma.eInputDeviceManager_getDevice(self, address)


    def getConnectedDevices(self):
        """getConnectedDevices(eInputDeviceManager self) -> eManagedInputDevicePtrList"""
        return _enigma.eInputDeviceManager_getConnectedDevices(self)


    def getAvailableDevices(self):
        """getAvailableDevices(eInputDeviceManager self) -> eManagedInputDevicePtrList"""
        return _enigma.eInputDeviceManager_getAvailableDevices(self)


    def rescan(self):
        """rescan(eInputDeviceManager self)"""
        return _enigma.eInputDeviceManager_rescan(self)


    def connectDevice(self, device):
        """connectDevice(eInputDeviceManager self, eManagedInputDevicePtr device)"""
        return _enigma.eInputDeviceManager_connectDevice(self, device)


    def disconnectDevice(self, device):
        """disconnectDevice(eInputDeviceManager self, eManagedInputDevicePtr device)"""
        return _enigma.eInputDeviceManager_disconnectDevice(self, device)


    def vibrate(self, device=0):
        """
        vibrate(eInputDeviceManager self, eManagedInputDevicePtr device=0)
        vibrate(eInputDeviceManager self)
        """
        return _enigma.eInputDeviceManager_vibrate(self, device)


    def setLedColor(self, *args):
        """
        setLedColor(eInputDeviceManager self, uint32_t rgb)
        setLedColor(eInputDeviceManager self, eManagedInputDevicePtr device, uint32_t rgb)
        """
        return _enigma.eInputDeviceManager_setLedColor(self, *args)


    def setLedColorIr(self, *args):
        """
        setLedColorIr(eInputDeviceManager self, uint32_t rgb)
        setLedColorIr(eInputDeviceManager self, eManagedInputDevicePtr device, uint32_t rgb)
        """
        return _enigma.eInputDeviceManager_setLedColorIr(self, *args)


    def setIrProtocol(self, device, isRepeat, irProtocol):
        """setIrProtocol(eInputDeviceManager self, eManagedInputDevicePtr device, bool isRepeat, IrProtocol irProtocol)"""
        return _enigma.eInputDeviceManager_setIrProtocol(self, device, isRepeat, irProtocol)


    def setIrKey(self, device, irKey):
        """setIrKey(eInputDeviceManager self, eManagedInputDevicePtr device, IrKey irKey)"""
        return _enigma.eInputDeviceManager_setIrKey(self, device, irKey)


    def resetIr(self, device):
        """resetIr(eInputDeviceManager self, eManagedInputDevicePtr device)"""
        return _enigma.eInputDeviceManager_resetIr(self, device)


    def getIrKeyCount(self, device):
        """getIrKeyCount(eInputDeviceManager self, eManagedInputDevicePtr device)"""
        return _enigma.eInputDeviceManager_getIrKeyCount(self, device)

    deviceStateChanged = _swig_property(_enigma.eInputDeviceManager_deviceStateChanged_get, _enigma.eInputDeviceManager_deviceStateChanged_set)
    unboundRemoteKeyPressed = _swig_property(_enigma.eInputDeviceManager_unboundRemoteKeyPressed_get, _enigma.eInputDeviceManager_unboundRemoteKeyPressed_set)
    irKeyCount = _swig_property(_enigma.eInputDeviceManager_irKeyCount_get, _enigma.eInputDeviceManager_irKeyCount_set)
    batteryLow = _swig_property(_enigma.eInputDeviceManager_batteryLow_get, _enigma.eInputDeviceManager_batteryLow_set)
    deviceListChanged = _swig_property(_enigma.eInputDeviceManager_deviceListChanged_get, _enigma.eInputDeviceManager_deviceListChanged_set)
eInputDeviceManager.start = new_instancemethod(_enigma.eInputDeviceManager_start, None, eInputDeviceManager)
eInputDeviceManager.stop = new_instancemethod(_enigma.eInputDeviceManager_stop, None, eInputDeviceManager)
eInputDeviceManager.hasFeature = new_instancemethod(_enigma.eInputDeviceManager_hasFeature, None, eInputDeviceManager)
eInputDeviceManager.available = new_instancemethod(_enigma.eInputDeviceManager_available, None, eInputDeviceManager)
eInputDeviceManager.responding = new_instancemethod(_enigma.eInputDeviceManager_responding, None, eInputDeviceManager)
eInputDeviceManager.version = new_instancemethod(_enigma.eInputDeviceManager_version, None, eInputDeviceManager)
eInputDeviceManager.getDevice = new_instancemethod(_enigma.eInputDeviceManager_getDevice, None, eInputDeviceManager)
eInputDeviceManager.getConnectedDevices = new_instancemethod(_enigma.eInputDeviceManager_getConnectedDevices, None, eInputDeviceManager)
eInputDeviceManager.getAvailableDevices = new_instancemethod(_enigma.eInputDeviceManager_getAvailableDevices, None, eInputDeviceManager)
eInputDeviceManager.rescan = new_instancemethod(_enigma.eInputDeviceManager_rescan, None, eInputDeviceManager)
eInputDeviceManager.connectDevice = new_instancemethod(_enigma.eInputDeviceManager_connectDevice, None, eInputDeviceManager)
eInputDeviceManager.disconnectDevice = new_instancemethod(_enigma.eInputDeviceManager_disconnectDevice, None, eInputDeviceManager)
eInputDeviceManager.vibrate = new_instancemethod(_enigma.eInputDeviceManager_vibrate, None, eInputDeviceManager)
eInputDeviceManager.setLedColor = new_instancemethod(_enigma.eInputDeviceManager_setLedColor, None, eInputDeviceManager)
eInputDeviceManager.setLedColorIr = new_instancemethod(_enigma.eInputDeviceManager_setLedColorIr, None, eInputDeviceManager)
eInputDeviceManager.setIrProtocol = new_instancemethod(_enigma.eInputDeviceManager_setIrProtocol, None, eInputDeviceManager)
eInputDeviceManager.setIrKey = new_instancemethod(_enigma.eInputDeviceManager_setIrKey, None, eInputDeviceManager)
eInputDeviceManager.resetIr = new_instancemethod(_enigma.eInputDeviceManager_resetIr, None, eInputDeviceManager)
eInputDeviceManager.getIrKeyCount = new_instancemethod(_enigma.eInputDeviceManager_getIrKeyCount, None, eInputDeviceManager)
eInputDeviceManager_swigregister = _enigma.eInputDeviceManager_swigregister
eInputDeviceManager_swigregister(eInputDeviceManager)

def eInputDeviceManager_getInstance():
    """eInputDeviceManager_getInstance() -> eInputDeviceManager"""
    return _enigma.eInputDeviceManager_getInstance()

class eManagedInputDevicePtrList(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.eManagedInputDevicePtrList_swiginit(self, _enigma.new_eManagedInputDevicePtrList(*args))
    __swig_destroy__ = _enigma.delete_eManagedInputDevicePtrList
eManagedInputDevicePtrList.iterator = new_instancemethod(_enigma.eManagedInputDevicePtrList_iterator, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__nonzero__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___nonzero__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__bool__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___bool__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__len__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___len__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__getslice__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___getslice__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__setslice__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___setslice__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__delslice__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___delslice__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__delitem__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___delitem__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__getitem__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___getitem__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.__setitem__ = new_instancemethod(_enigma.eManagedInputDevicePtrList___setitem__, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.pop = new_instancemethod(_enigma.eManagedInputDevicePtrList_pop, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.append = new_instancemethod(_enigma.eManagedInputDevicePtrList_append, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.empty = new_instancemethod(_enigma.eManagedInputDevicePtrList_empty, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.size = new_instancemethod(_enigma.eManagedInputDevicePtrList_size, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.swap = new_instancemethod(_enigma.eManagedInputDevicePtrList_swap, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.begin = new_instancemethod(_enigma.eManagedInputDevicePtrList_begin, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.end = new_instancemethod(_enigma.eManagedInputDevicePtrList_end, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.rbegin = new_instancemethod(_enigma.eManagedInputDevicePtrList_rbegin, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.rend = new_instancemethod(_enigma.eManagedInputDevicePtrList_rend, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.clear = new_instancemethod(_enigma.eManagedInputDevicePtrList_clear, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.get_allocator = new_instancemethod(_enigma.eManagedInputDevicePtrList_get_allocator, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.pop_back = new_instancemethod(_enigma.eManagedInputDevicePtrList_pop_back, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.erase = new_instancemethod(_enigma.eManagedInputDevicePtrList_erase, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.push_back = new_instancemethod(_enigma.eManagedInputDevicePtrList_push_back, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.front = new_instancemethod(_enigma.eManagedInputDevicePtrList_front, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.back = new_instancemethod(_enigma.eManagedInputDevicePtrList_back, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.assign = new_instancemethod(_enigma.eManagedInputDevicePtrList_assign, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.resize = new_instancemethod(_enigma.eManagedInputDevicePtrList_resize, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.insert = new_instancemethod(_enigma.eManagedInputDevicePtrList_insert, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.pop_front = new_instancemethod(_enigma.eManagedInputDevicePtrList_pop_front, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.push_front = new_instancemethod(_enigma.eManagedInputDevicePtrList_push_front, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList.reverse = new_instancemethod(_enigma.eManagedInputDevicePtrList_reverse, None, eManagedInputDevicePtrList)
eManagedInputDevicePtrList_swigregister = _enigma.eManagedInputDevicePtrList_swigregister
eManagedInputDevicePtrList_swigregister(eManagedInputDevicePtrList)

class IrProtocol(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    carrier_period = _swig_property(_enigma.IrProtocol_carrier_period_get, _enigma.IrProtocol_carrier_period_set)
    carrier_low = _swig_property(_enigma.IrProtocol_carrier_low_get, _enigma.IrProtocol_carrier_low_set)
    toggle_mask = _swig_property(_enigma.IrProtocol_toggle_mask_get, _enigma.IrProtocol_toggle_mask_set)
    startbits = _swig_property(_enigma.IrProtocol_startbits_get, _enigma.IrProtocol_startbits_set)
    start_ontime = _swig_property(_enigma.IrProtocol_start_ontime_get, _enigma.IrProtocol_start_ontime_set)
    start_totaltime = _swig_property(_enigma.IrProtocol_start_totaltime_get, _enigma.IrProtocol_start_totaltime_set)
    one_ontime = _swig_property(_enigma.IrProtocol_one_ontime_get, _enigma.IrProtocol_one_ontime_set)
    one_totaltime = _swig_property(_enigma.IrProtocol_one_totaltime_get, _enigma.IrProtocol_one_totaltime_set)
    zero_ontime = _swig_property(_enigma.IrProtocol_zero_ontime_get, _enigma.IrProtocol_zero_ontime_set)
    zero_totaltime = _swig_property(_enigma.IrProtocol_zero_totaltime_get, _enigma.IrProtocol_zero_totaltime_set)
    stopbits = _swig_property(_enigma.IrProtocol_stopbits_get, _enigma.IrProtocol_stopbits_set)
    stop_ontime = _swig_property(_enigma.IrProtocol_stop_ontime_get, _enigma.IrProtocol_stop_ontime_set)
    stop_totaltime = _swig_property(_enigma.IrProtocol_stop_totaltime_get, _enigma.IrProtocol_stop_totaltime_set)
    repeat_ms = _swig_property(_enigma.IrProtocol_repeat_ms_get, _enigma.IrProtocol_repeat_ms_set)
    repeat_id = _swig_property(_enigma.IrProtocol_repeat_id_get, _enigma.IrProtocol_repeat_id_set)
    IR_PROTO_NEC = _enigma.IrProtocol_IR_PROTO_NEC
    IR_PROTO_SIRC = _enigma.IrProtocol_IR_PROTO_SIRC
    IR_PROTO_JVC = _enigma.IrProtocol_IR_PROTO_JVC
    IR_PROTO_RC5 = _enigma.IrProtocol_IR_PROTO_RC5
    IR_PROTO_REP_NEC = _enigma.IrProtocol_IR_PROTO_REP_NEC
    IR_PROTO_REP_JVC = _enigma.IrProtocol_IR_PROTO_REP_JVC
    IR_PROTO_CUSTOM = _enigma.IrProtocol_IR_PROTO_CUSTOM
    IR_PROTO_REP_CUSTOM = _enigma.IrProtocol_IR_PROTO_REP_CUSTOM

    def __init__(self, carr_period, carr_low, tggl_mask, strtbits, start_on, start_total, one_on, one_total, zero_on, zero_total, stopbts, stop_on, stop_total, repeat_millis, repeat_proto_id):
        """__init__(IrProtocol self, uint16_t carr_period, uint16_t carr_low, uint32_t tggl_mask, uint8_t strtbits, uint16_t start_on, uint16_t start_total, uint16_t one_on, uint16_t one_total, uint16_t zero_on, uint16_t zero_total, uint8_t stopbts, uint16_t stop_on, uint16_t stop_total, uint8_t repeat_millis, uint8_t repeat_proto_id) -> IrProtocol"""
        _enigma.IrProtocol_swiginit(self, _enigma.new_IrProtocol(carr_period, carr_low, tggl_mask, strtbits, start_on, start_total, one_on, one_total, zero_on, zero_total, stopbts, stop_on, stop_total, repeat_millis, repeat_proto_id))
    __swig_destroy__ = _enigma.delete_IrProtocol
IrProtocol_swigregister = _enigma.IrProtocol_swigregister
IrProtocol_swigregister(IrProtocol)

class IrKey(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CODE_POWER = _enigma.IrKey_CODE_POWER
    CODE_MODE = _enigma.IrKey_CODE_MODE
    CODE_MUTE = _enigma.IrKey_CODE_MUTE
    CODE_1 = _enigma.IrKey_CODE_1
    CODE_2 = _enigma.IrKey_CODE_2
    CODE_3 = _enigma.IrKey_CODE_3
    CODE_4 = _enigma.IrKey_CODE_4
    CODE_5 = _enigma.IrKey_CODE_5
    CODE_6 = _enigma.IrKey_CODE_6
    CODE_7 = _enigma.IrKey_CODE_7
    CODE_8 = _enigma.IrKey_CODE_8
    CODE_9 = _enigma.IrKey_CODE_9
    CODE_0 = _enigma.IrKey_CODE_0
    CODE_REWIND = _enigma.IrKey_CODE_REWIND
    CODE_FASTFORWARD = _enigma.IrKey_CODE_FASTFORWARD
    CODE_VOLUMEUP = _enigma.IrKey_CODE_VOLUMEUP
    CODE_VOLUMEDOWN = _enigma.IrKey_CODE_VOLUMEDOWN
    CODE_EXIT = _enigma.IrKey_CODE_EXIT
    CODE_CHANNELUP = _enigma.IrKey_CODE_CHANNELUP
    CODE_CHANNELDOWN = _enigma.IrKey_CODE_CHANNELDOWN
    CODE_INFO = _enigma.IrKey_CODE_INFO
    CODE_MENU = _enigma.IrKey_CODE_MENU
    CODE_AUDIO = _enigma.IrKey_CODE_AUDIO
    CODE_VIDEO = _enigma.IrKey_CODE_VIDEO
    CODE_UP = _enigma.IrKey_CODE_UP
    CODE_DOWN = _enigma.IrKey_CODE_DOWN
    CODE_LEFT = _enigma.IrKey_CODE_LEFT
    CODE_RIGHT = _enigma.IrKey_CODE_RIGHT
    CODE_OK = _enigma.IrKey_CODE_OK
    CODE_RED = _enigma.IrKey_CODE_RED
    CODE_GREEN = _enigma.IrKey_CODE_GREEN
    CODE_YELLOW = _enigma.IrKey_CODE_YELLOW
    CODE_BLUE = _enigma.IrKey_CODE_BLUE
    CODE_PREVIOUSSONG = _enigma.IrKey_CODE_PREVIOUSSONG
    CODE_PLAY = _enigma.IrKey_CODE_PLAY
    CODE_STOP = _enigma.IrKey_CODE_STOP
    CODE_NEXSONG = _enigma.IrKey_CODE_NEXSONG
    CODE_TEXT = _enigma.IrKey_CODE_TEXT
    CODE_RECORD = _enigma.IrKey_CODE_RECORD
    keycode = _swig_property(_enigma.IrKey_keycode_get, _enigma.IrKey_keycode_set)
    protocol_id = _swig_property(_enigma.IrKey_protocol_id_get, _enigma.IrKey_protocol_id_set)
    make_msg = _swig_property(_enigma.IrKey_make_msg_get, _enigma.IrKey_make_msg_set)
    make_len = _swig_property(_enigma.IrKey_make_len_get, _enigma.IrKey_make_len_set)
    break_msg = _swig_property(_enigma.IrKey_break_msg_get, _enigma.IrKey_break_msg_set)
    break_len = _swig_property(_enigma.IrKey_break_len_get, _enigma.IrKey_break_len_set)

    def __init__(self, keycode, proto_id, make_message, make_message_len, break_message, break_message_len):
        """__init__(IrKey self, int32_t keycode, uint8_t proto_id, uint32_t make_message, uint8_t make_message_len, uint32_t break_message, uint8_t break_message_len) -> IrKey"""
        _enigma.IrKey_swiginit(self, _enigma.new_IrKey(keycode, proto_id, make_message, make_message_len, break_message, break_message_len))
    __swig_destroy__ = _enigma.delete_IrKey
IrKey_swigregister = _enigma.IrKey_swigregister
IrKey_swigregister(IrKey)

class eManagedInputDevice(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
    TYPE_UNDEF = _enigma.eManagedInputDevice_TYPE_UNDEF
    TYPE_DREAMBLE = _enigma.eManagedInputDevice_TYPE_DREAMBLE
    STATE_DISCONNECTED = _enigma.eManagedInputDevice_STATE_DISCONNECTED
    STATE_CONNECTING = _enigma.eManagedInputDevice_STATE_CONNECTING
    STATE_CONNECTED = _enigma.eManagedInputDevice_STATE_CONNECTED

    def address(self):
        """address(eManagedInputDevice self) -> std::string const"""
        return _enigma.eManagedInputDevice_address(self)


    def name(self):
        """name(eManagedInputDevice self) -> std::string const"""
        return _enigma.eManagedInputDevice_name(self)


    def shortName(self):
        """shortName(eManagedInputDevice self) -> std::string const"""
        return _enigma.eManagedInputDevice_shortName(self)


    def version(self):
        """version(eManagedInputDevice self) -> std::string const"""
        return _enigma.eManagedInputDevice_version(self)


    def batteryLevel(self):
        """batteryLevel(eManagedInputDevice self) -> int"""
        return _enigma.eManagedInputDevice_batteryLevel(self)


    def rssi(self):
        """rssi(eManagedInputDevice self) -> int"""
        return _enigma.eManagedInputDevice_rssi(self)


    def encrypted(self):
        """encrypted(eManagedInputDevice self) -> bool"""
        return _enigma.eManagedInputDevice_encrypted(self)


    def state(self):
        """state(eManagedInputDevice self) -> int"""
        return _enigma.eManagedInputDevice_state(self)


    def connected(self):
        """connected(eManagedInputDevice self) -> bool"""
        return _enigma.eManagedInputDevice_connected(self)


    def bound(self):
        """bound(eManagedInputDevice self) -> bool"""
        return _enigma.eManagedInputDevice_bound(self)


    def ready(self):
        """ready(eManagedInputDevice self) -> bool"""
        return _enigma.eManagedInputDevice_ready(self)


    def checkVersion(self, major, minor=0):
        """
        checkVersion(eManagedInputDevice self, uint32_t major, uint32_t minor=0) -> int
        checkVersion(eManagedInputDevice self, uint32_t major) -> int
        """
        return _enigma.eManagedInputDevice_checkVersion(self, major, minor)


    def connect(self):
        """connect(eManagedInputDevice self)"""
        return _enigma.eManagedInputDevice_connect(self)


    def disconnect(self):
        """disconnect(eManagedInputDevice self)"""
        return _enigma.eManagedInputDevice_disconnect(self)


    def vibrate(self):
        """vibrate(eManagedInputDevice self)"""
        return _enigma.eManagedInputDevice_vibrate(self)


    def setLedColor(self, color):
        """setLedColor(eManagedInputDevice self, uint32_t color)"""
        return _enigma.eManagedInputDevice_setLedColor(self, color)


    def setLedColorIr(self, color):
        """setLedColorIr(eManagedInputDevice self, uint32_t color)"""
        return _enigma.eManagedInputDevice_setLedColorIr(self, color)


    def setIrProtocol(self, isRepeat, protocolData):
        """setIrProtocol(eManagedInputDevice self, bool isRepeat, IrProtocol protocolData)"""
        return _enigma.eManagedInputDevice_setIrProtocol(self, isRepeat, protocolData)


    def setIrKey(self, keyData):
        """setIrKey(eManagedInputDevice self, IrKey keyData)"""
        return _enigma.eManagedInputDevice_setIrKey(self, keyData)


    def resetIr(self):
        """resetIr(eManagedInputDevice self)"""
        return _enigma.eManagedInputDevice_resetIr(self)


    def getIrKeyCount(self):
        """getIrKeyCount(eManagedInputDevice self)"""
        return _enigma.eManagedInputDevice_getIrKeyCount(self)

eManagedInputDevice.address = new_instancemethod(_enigma.eManagedInputDevice_address, None, eManagedInputDevice)
eManagedInputDevice.name = new_instancemethod(_enigma.eManagedInputDevice_name, None, eManagedInputDevice)
eManagedInputDevice.shortName = new_instancemethod(_enigma.eManagedInputDevice_shortName, None, eManagedInputDevice)
eManagedInputDevice.version = new_instancemethod(_enigma.eManagedInputDevice_version, None, eManagedInputDevice)
eManagedInputDevice.batteryLevel = new_instancemethod(_enigma.eManagedInputDevice_batteryLevel, None, eManagedInputDevice)
eManagedInputDevice.rssi = new_instancemethod(_enigma.eManagedInputDevice_rssi, None, eManagedInputDevice)
eManagedInputDevice.encrypted = new_instancemethod(_enigma.eManagedInputDevice_encrypted, None, eManagedInputDevice)
eManagedInputDevice.state = new_instancemethod(_enigma.eManagedInputDevice_state, None, eManagedInputDevice)
eManagedInputDevice.connected = new_instancemethod(_enigma.eManagedInputDevice_connected, None, eManagedInputDevice)
eManagedInputDevice.bound = new_instancemethod(_enigma.eManagedInputDevice_bound, None, eManagedInputDevice)
eManagedInputDevice.ready = new_instancemethod(_enigma.eManagedInputDevice_ready, None, eManagedInputDevice)
eManagedInputDevice.checkVersion = new_instancemethod(_enigma.eManagedInputDevice_checkVersion, None, eManagedInputDevice)
eManagedInputDevice.connect = new_instancemethod(_enigma.eManagedInputDevice_connect, None, eManagedInputDevice)
eManagedInputDevice.disconnect = new_instancemethod(_enigma.eManagedInputDevice_disconnect, None, eManagedInputDevice)
eManagedInputDevice.vibrate = new_instancemethod(_enigma.eManagedInputDevice_vibrate, None, eManagedInputDevice)
eManagedInputDevice.setLedColor = new_instancemethod(_enigma.eManagedInputDevice_setLedColor, None, eManagedInputDevice)
eManagedInputDevice.setLedColorIr = new_instancemethod(_enigma.eManagedInputDevice_setLedColorIr, None, eManagedInputDevice)
eManagedInputDevice.setIrProtocol = new_instancemethod(_enigma.eManagedInputDevice_setIrProtocol, None, eManagedInputDevice)
eManagedInputDevice.setIrKey = new_instancemethod(_enigma.eManagedInputDevice_setIrKey, None, eManagedInputDevice)
eManagedInputDevice.resetIr = new_instancemethod(_enigma.eManagedInputDevice_resetIr, None, eManagedInputDevice)
eManagedInputDevice.getIrKeyCount = new_instancemethod(_enigma.eManagedInputDevice_getIrKeyCount, None, eManagedInputDevice)
eManagedInputDevice_swigregister = _enigma.eManagedInputDevice_swigregister
eManagedInputDevice_swigregister(eManagedInputDevice)

class eManagedInputDevicePtr(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.eManagedInputDevicePtr_swiginit(self, _enigma.new_eManagedInputDevicePtr(*args))
    __swig_destroy__ = _enigma.delete_eManagedInputDevicePtr

    def address(self):
        """address(eManagedInputDevicePtr self) -> std::string const"""
        return _enigma.eManagedInputDevicePtr_address(self)


    def name(self):
        """name(eManagedInputDevicePtr self) -> std::string const"""
        return _enigma.eManagedInputDevicePtr_name(self)


    def shortName(self):
        """shortName(eManagedInputDevicePtr self) -> std::string const"""
        return _enigma.eManagedInputDevicePtr_shortName(self)


    def version(self):
        """version(eManagedInputDevicePtr self) -> std::string const"""
        return _enigma.eManagedInputDevicePtr_version(self)


    def batteryLevel(self):
        """batteryLevel(eManagedInputDevicePtr self) -> int"""
        return _enigma.eManagedInputDevicePtr_batteryLevel(self)


    def rssi(self):
        """rssi(eManagedInputDevicePtr self) -> int"""
        return _enigma.eManagedInputDevicePtr_rssi(self)


    def encrypted(self):
        """encrypted(eManagedInputDevicePtr self) -> bool"""
        return _enigma.eManagedInputDevicePtr_encrypted(self)


    def state(self):
        """state(eManagedInputDevicePtr self) -> int"""
        return _enigma.eManagedInputDevicePtr_state(self)


    def connected(self):
        """connected(eManagedInputDevicePtr self) -> bool"""
        return _enigma.eManagedInputDevicePtr_connected(self)


    def bound(self):
        """bound(eManagedInputDevicePtr self) -> bool"""
        return _enigma.eManagedInputDevicePtr_bound(self)


    def ready(self):
        """ready(eManagedInputDevicePtr self) -> bool"""
        return _enigma.eManagedInputDevicePtr_ready(self)


    def checkVersion(self, major, minor=0):
        """
        checkVersion(eManagedInputDevicePtr self, uint32_t major, uint32_t minor=0) -> int
        checkVersion(eManagedInputDevicePtr self, uint32_t major) -> int
        """
        return _enigma.eManagedInputDevicePtr_checkVersion(self, major, minor)


    def connect(self):
        """connect(eManagedInputDevicePtr self)"""
        return _enigma.eManagedInputDevicePtr_connect(self)


    def disconnect(self):
        """disconnect(eManagedInputDevicePtr self)"""
        return _enigma.eManagedInputDevicePtr_disconnect(self)


    def vibrate(self):
        """vibrate(eManagedInputDevicePtr self)"""
        return _enigma.eManagedInputDevicePtr_vibrate(self)


    def setLedColor(self, color):
        """setLedColor(eManagedInputDevicePtr self, uint32_t color)"""
        return _enigma.eManagedInputDevicePtr_setLedColor(self, color)


    def setLedColorIr(self, color):
        """setLedColorIr(eManagedInputDevicePtr self, uint32_t color)"""
        return _enigma.eManagedInputDevicePtr_setLedColorIr(self, color)


    def setIrProtocol(self, isRepeat, protocolData):
        """setIrProtocol(eManagedInputDevicePtr self, bool isRepeat, IrProtocol protocolData)"""
        return _enigma.eManagedInputDevicePtr_setIrProtocol(self, isRepeat, protocolData)


    def setIrKey(self, keyData):
        """setIrKey(eManagedInputDevicePtr self, IrKey keyData)"""
        return _enigma.eManagedInputDevicePtr_setIrKey(self, keyData)


    def resetIr(self):
        """resetIr(eManagedInputDevicePtr self)"""
        return _enigma.eManagedInputDevicePtr_resetIr(self)


    def getIrKeyCount(self):
        """getIrKeyCount(eManagedInputDevicePtr self)"""
        return _enigma.eManagedInputDevicePtr_getIrKeyCount(self)

eManagedInputDevicePtr.__ref__ = new_instancemethod(_enigma.eManagedInputDevicePtr___ref__, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.getPtrString = new_instancemethod(_enigma.eManagedInputDevicePtr_getPtrString, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.__deref__ = new_instancemethod(_enigma.eManagedInputDevicePtr___deref__, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.address = new_instancemethod(_enigma.eManagedInputDevicePtr_address, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.name = new_instancemethod(_enigma.eManagedInputDevicePtr_name, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.shortName = new_instancemethod(_enigma.eManagedInputDevicePtr_shortName, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.version = new_instancemethod(_enigma.eManagedInputDevicePtr_version, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.batteryLevel = new_instancemethod(_enigma.eManagedInputDevicePtr_batteryLevel, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.rssi = new_instancemethod(_enigma.eManagedInputDevicePtr_rssi, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.encrypted = new_instancemethod(_enigma.eManagedInputDevicePtr_encrypted, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.state = new_instancemethod(_enigma.eManagedInputDevicePtr_state, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.connected = new_instancemethod(_enigma.eManagedInputDevicePtr_connected, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.bound = new_instancemethod(_enigma.eManagedInputDevicePtr_bound, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.ready = new_instancemethod(_enigma.eManagedInputDevicePtr_ready, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.checkVersion = new_instancemethod(_enigma.eManagedInputDevicePtr_checkVersion, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.connect = new_instancemethod(_enigma.eManagedInputDevicePtr_connect, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.disconnect = new_instancemethod(_enigma.eManagedInputDevicePtr_disconnect, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.vibrate = new_instancemethod(_enigma.eManagedInputDevicePtr_vibrate, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.setLedColor = new_instancemethod(_enigma.eManagedInputDevicePtr_setLedColor, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.setLedColorIr = new_instancemethod(_enigma.eManagedInputDevicePtr_setLedColorIr, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.setIrProtocol = new_instancemethod(_enigma.eManagedInputDevicePtr_setIrProtocol, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.setIrKey = new_instancemethod(_enigma.eManagedInputDevicePtr_setIrKey, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.resetIr = new_instancemethod(_enigma.eManagedInputDevicePtr_resetIr, None, eManagedInputDevicePtr)
eManagedInputDevicePtr.getIrKeyCount = new_instancemethod(_enigma.eManagedInputDevicePtr_getIrKeyCount, None, eManagedInputDevicePtr)
eManagedInputDevicePtr_swigregister = _enigma.eManagedInputDevicePtr_swigregister
eManagedInputDevicePtr_swigregister(eManagedInputDevicePtr)

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 eFileEvent(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
    ACCESS = _enigma.eFileEvent_ACCESS
    MODIFY = _enigma.eFileEvent_MODIFY
    ATTRIB = _enigma.eFileEvent_ATTRIB
    CLOSE_WRITE = _enigma.eFileEvent_CLOSE_WRITE
    CLOSE_NOWRITE = _enigma.eFileEvent_CLOSE_NOWRITE
    CLOSE = _enigma.eFileEvent_CLOSE
    OPEN = _enigma.eFileEvent_OPEN
    MOVED_FROM = _enigma.eFileEvent_MOVED_FROM
    MOVED_TO = _enigma.eFileEvent_MOVED_TO
    MOVE = _enigma.eFileEvent_MOVE
    CREATE = _enigma.eFileEvent_CREATE
    DELETE = _enigma.eFileEvent_DELETE
    DELETE_SELF = _enigma.eFileEvent_DELETE_SELF
    MOVE_SELF = _enigma.eFileEvent_MOVE_SELF
    ISDIR = _enigma.eFileEvent_ISDIR
    __swig_destroy__ = _enigma.delete_eFileEvent
eFileEvent.getWd = new_instancemethod(_enigma.eFileEvent_getWd, None, eFileEvent)
eFileEvent.getMask = new_instancemethod(_enigma.eFileEvent_getMask, None, eFileEvent)
eFileEvent.getCookie = new_instancemethod(_enigma.eFileEvent_getCookie, None, eFileEvent)
eFileEvent.getName = new_instancemethod(_enigma.eFileEvent_getName, None, eFileEvent)
eFileEvent.getPath = new_instancemethod(_enigma.eFileEvent_getPath, None, eFileEvent)
eFileEvent.getFullPath = new_instancemethod(_enigma.eFileEvent_getFullPath, None, eFileEvent)
eFileEvent.getMovedFrom = new_instancemethod(_enigma.eFileEvent_getMovedFrom, None, eFileEvent)
eFileEvent.getMovedTo = new_instancemethod(_enigma.eFileEvent_getMovedTo, None, eFileEvent)
eFileEvent_swigregister = _enigma.eFileEvent_swigregister
eFileEvent_swigregister(eFileEvent)

class eFileWatch(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.eFileWatch_swiginit(self, _enigma.new_eFileWatch(*args))
    __swig_destroy__ = _enigma.delete_eFileWatch
    setVerboseDebug = staticmethod(_enigma.eFileWatch_setVerboseDebug)
    fileChanged = _swig_property(_enigma.eFileWatch_fileChanged_get, _enigma.eFileWatch_fileChanged_set)
eFileWatch.startWatching = new_instancemethod(_enigma.eFileWatch_startWatching, None, eFileWatch)
eFileWatch.stopWatching = new_instancemethod(_enigma.eFileWatch_stopWatching, None, eFileWatch)
eFileWatch.isWatching = new_instancemethod(_enigma.eFileWatch_isWatching, None, eFileWatch)
eFileWatch.getWd = new_instancemethod(_enigma.eFileWatch_getWd, None, eFileWatch)
eFileWatch.getDirectory = new_instancemethod(_enigma.eFileWatch_getDirectory, None, eFileWatch)
eFileWatch.getMask = new_instancemethod(_enigma.eFileWatch_getMask, None, eFileWatch)
eFileWatch.setDirectory = new_instancemethod(_enigma.eFileWatch_setDirectory, None, eFileWatch)
eFileWatch.__eq__ = new_instancemethod(_enigma.eFileWatch___eq__, None, eFileWatch)
eFileWatch_swigregister = _enigma.eFileWatch_swigregister
eFileWatch_swigregister(eFileWatch)

def eFileWatch_setVerboseDebug(val):
    return _enigma.eFileWatch_setVerboseDebug(val)
eFileWatch_setVerboseDebug = _enigma.eFileWatch_setVerboseDebug

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, bands):
        _enigma.eMusicPlayer_swiginit(self, _enigma.new_eMusicPlayer(bands))
    __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 const &"""
        return _enigma.eMediaDatabaseResult_errorDriverText(self)


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


    def data(self):
        """data(eMediaDatabaseResult self) -> databaseResultVector"""
        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 resetDatabase(self):
        """resetDatabase(eMediaDatabase self) -> bool"""
        return _enigma.eMediaDatabase_resetDatabase(self)


    def getCurrentScanPath(self):
        """getCurrentScanPath(eMediaDatabase self)"""
        return _enigma.eMediaDatabase_getCurrentScanPath(self)


    def getEnqueuedPaths(self, OUTPUT):
        """getEnqueuedPaths(eMediaDatabase self, StringList OUTPUT)"""
        return _enigma.eMediaDatabase_getEnqueuedPaths(self, OUTPUT)


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


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


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


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


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


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


    def getAllDirectories(self):
        """getAllDirectories(eMediaDatabase self) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getAllDirectories(self)


    def filterAudio(self, needle, limit=-1, offset=0):
        """
        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, needle, limit, offset)


    def filterByAlbum(self, album, limit=-1, offset=0):
        """
        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, album, limit, offset)


    def filterByArtistAlbum(self, artist, album, limit=-1, offset=0):
        """
        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, artist, album, limit, offset)


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


    def filterByArtist(self, artist, limit=-1, offset=0):
        """
        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, artist, limit, offset)


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


    def filterByGenre(self, genre, limit=-1, offset=0):
        """
        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, genre, limit, offset)


    def filterByTitle(self, title, limit=-1, offset=0):
        """
        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, title, limit, offset)


    def getAllArtists(self, limit=-1, offset=0):
        """
        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, limit, offset)


    def getAllAlbumArtists(self, limit=-1, offset=0):
        """
        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, limit, offset)


    def getArtists(self, artist, limit=-1, offset=0):
        """
        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, artist, limit, offset)


    def getAllAlbums(self, limit=-1, offset=0):
        """
        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, limit, offset)


    def getAlbums(self, album, limit=-1, offset=0):
        """
        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, album, limit, offset)


    def getAlbumsByArtist(self, artist, limit=-1, offset=0):
        """
        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, artist, limit, offset)


    def getAlbumsByAlbumArtist(self, album_artist, limit=-1, offset=0):
        """
        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, album_artist, limit, offset)


    def getTracksByAlbumId(self, album_id):
        """getTracksByAlbumId(eMediaDatabase self, int album_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getTracksByAlbumId(self, album_id)


    def getAllAudio(self, limit=-1, offset=0):
        """
        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, limit, offset)


    def getAllVideos(self, limit=-1, offset=0):
        """
        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, limit, offset)


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


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


    def getAllRecordings(self, limit=-1, offset=0):
        """
        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, limit, offset)


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


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


    def setRecordMeta(self, file_id, ref, name, description, service_data, duration, filesize, lastmodified, created):
        """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, int lastmodified, int created) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_setRecordMeta(self, file_id, ref, name, description, service_data, duration, filesize, lastmodified, created)


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


    def setRecordEit(self, file_id, eit_raw, update=False):
        """
        setRecordEit(eMediaDatabase self, int file_id, uint8_t [] eit_raw, bool update=False) -> eMediaDatabaseResultPtr
        setRecordEit(eMediaDatabase self, int file_id, uint8_t [] eit_raw) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_setRecordEit(self, file_id, eit_raw, update)


    def getRecordTags(self, file_id):
        """getRecordTags(eMediaDatabase self, int file_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getRecordTags(self, file_id)


    def setRecordTags(self, file_id, tags):
        """setRecordTags(eMediaDatabase self, int file_id, StringVector tags) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_setRecordTags(self, file_id, tags)


    def setLastPlayed(self, file_id, lastplayed, lastplaypos):
        """setLastPlayed(eMediaDatabase self, int file_id, int64_t lastplayed, int64_t lastplaypos) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_setLastPlayed(self, file_id, lastplayed, lastplaypos)


    def getLastPlayed(self, file_id, lastplayed, lastplaypos):
        """getLastPlayed(eMediaDatabase self, int file_id, int64_t & lastplayed, int64_t & lastplaypos)"""
        return _enigma.eMediaDatabase_getLastPlayed(self, file_id, lastplayed, lastplaypos)


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


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


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


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


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


    def getFileAttributeValue(self, file_id, key):
        """getFileAttributeValue(eMediaDatabase self, int file_id, std::string const & key)"""
        return _enigma.eMediaDatabase_getFileAttributeValue(self, file_id, key)


    def getCoverArt(self, *args):
        """
        getCoverArt(eMediaDatabase self, int cover_art_id, eSize size, eSize aspect)
        getCoverArt(eMediaDatabase self, int cover_art_id, eSize size)
        getCoverArt(eMediaDatabase self, int cover_art_id)
        """
        return _enigma.eMediaDatabase_getCoverArt(self, *args)


    def getCoverArtData(self, *args):
        """
        getCoverArtData(eMediaDatabase self, int cover_art_id) -> eMediaDatabaseResultPtr
        getCoverArtData(eMediaDatabase self, std::string const & cover_art_key) -> eMediaDatabaseResultPtr
        """
        return _enigma.eMediaDatabase_getCoverArtData(self, *args)


    def getAlbumCoverArt(self, *args):
        """
        getAlbumCoverArt(eMediaDatabase self, int cover_art_id, eSize size, eSize aspect)
        getAlbumCoverArt(eMediaDatabase self, int cover_art_id, eSize size)
        getAlbumCoverArt(eMediaDatabase self, int cover_art_id)
        """
        return _enigma.eMediaDatabase_getAlbumCoverArt(self, *args)


    def getAlbumCoverArtData(self, album_id):
        """getAlbumCoverArtData(eMediaDatabase self, int album_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getAlbumCoverArtData(self, album_id)


    def getAlbumCoverArtId(self, album_id):
        """getAlbumCoverArtId(eMediaDatabase self, int album_id) -> eMediaDatabaseResultPtr"""
        return _enigma.eMediaDatabase_getAlbumCoverArtId(self, album_id)


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


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


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


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


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


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


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


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


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


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


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


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


    def query(self, *args):
        """
        query(eMediaDatabase self, std::string const & sql, StringList values, bool rw=False) -> eMediaDatabaseResultPtr
        query(eMediaDatabase self, std::string const & sql, StringList values) -> 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)
eMediaDatabase.resetDatabase = new_instancemethod(_enigma.eMediaDatabase_resetDatabase, None, eMediaDatabase)
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.getAllDirectories = new_instancemethod(_enigma.eMediaDatabase_getAllDirectories, 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.filterByAlbumArtistAlbum = new_instancemethod(_enigma.eMediaDatabase_filterByAlbumArtistAlbum, None, eMediaDatabase)
eMediaDatabase.filterByArtist = new_instancemethod(_enigma.eMediaDatabase_filterByArtist, None, eMediaDatabase)
eMediaDatabase.filterByAlbumArtist = new_instancemethod(_enigma.eMediaDatabase_filterByAlbumArtist, 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.getTracksByAlbumId = new_instancemethod(_enigma.eMediaDatabase_getTracksByAlbumId, None, eMediaDatabase)
eMediaDatabase.getAllAudio = new_instancemethod(_enigma.eMediaDatabase_getAllAudio, None, eMediaDatabase)
eMediaDatabase.getAllVideos = new_instancemethod(_enigma.eMediaDatabase_getAllVideos, None, eMediaDatabase)
eMediaDatabase.getVideos = new_instancemethod(_enigma.eMediaDatabase_getVideos, 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.getRecordTags = new_instancemethod(_enigma.eMediaDatabase_getRecordTags, None, eMediaDatabase)
eMediaDatabase.setRecordTags = new_instancemethod(_enigma.eMediaDatabase_setRecordTags, None, eMediaDatabase)
eMediaDatabase.setLastPlayed = new_instancemethod(_enigma.eMediaDatabase_setLastPlayed, None, eMediaDatabase)
eMediaDatabase.getLastPlayed = new_instancemethod(_enigma.eMediaDatabase_getLastPlayed, 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.getFileAttributeValue = new_instancemethod(_enigma.eMediaDatabase_getFileAttributeValue, None, eMediaDatabase)
eMediaDatabase.getCoverArt = new_instancemethod(_enigma.eMediaDatabase_getCoverArt, None, eMediaDatabase)
eMediaDatabase.getCoverArtData = new_instancemethod(_enigma.eMediaDatabase_getCoverArtData, None, eMediaDatabase)
eMediaDatabase.getAlbumCoverArt = new_instancemethod(_enigma.eMediaDatabase_getAlbumCoverArt, None, eMediaDatabase)
eMediaDatabase.getAlbumCoverArtData = new_instancemethod(_enigma.eMediaDatabase_getAlbumCoverArtData, None, eMediaDatabase)
eMediaDatabase.getAlbumCoverArtId = new_instancemethod(_enigma.eMediaDatabase_getAlbumCoverArtId, 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
eMediaDatabase.FIELD_COVER_ART_ID = _enigma.cvar.eMediaDatabase_FIELD_COVER_ART_ID
eMediaDatabase.FIELD_SAVED_AUDIO_TRACK = _enigma.cvar.eMediaDatabase_FIELD_SAVED_AUDIO_TRACK
eMediaDatabase.FIELD_SAVED_SUBTITLE_TRACK = _enigma.cvar.eMediaDatabase_FIELD_SAVED_SUBTITLE_TRACK
eMediaDatabase.FIELD_TAG_ID = _enigma.cvar.eMediaDatabase_FIELD_TAG_ID
eMediaDatabase.FIELD_TAG = _enigma.cvar.eMediaDatabase_FIELD_TAG
eMediaDatabase.FIELD_TAGS = _enigma.cvar.eMediaDatabase_FIELD_TAGS
eMediaDatabase.FIELD_CREATED = _enigma.cvar.eMediaDatabase_FIELD_CREATED

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 const &"""
        return _enigma.eMediaDatabaseResultPtr_errorDriverText(self)


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


    def data(self):
        """data(eMediaDatabaseResultPtr self) -> databaseResultVector"""
        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, enabled):
        """setOfflineMode(eNetworkManager self, bool enabled)"""
        return _enigma.eNetworkManager_setOfflineMode(self, enabled)


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


    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, values):
        """sendUserReply(eNetworkManager self, StringMap values)"""
        return _enigma.eNetworkManager_sendUserReply(self, values)


    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)


    def timeUpdates(self):
        """timeUpdates(eNetworkManager self) -> std::string const"""
        return _enigma.eNetworkManager_timeUpdates(self)


    def setTimeUpdates(self, type):
        """setTimeUpdates(eNetworkManager self, std::string const & type)"""
        return _enigma.eNetworkManager_setTimeUpdates(self, type)


    def getTimeservers(self):
        """getTimeservers(eNetworkManager self) -> StringList"""
        return _enigma.eNetworkManager_getTimeservers(self)


    def setTimeservers(self, servers):
        """setTimeservers(eNetworkManager self, StringList servers)"""
        return _enigma.eNetworkManager_setTimeservers(self, servers)

    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)
    timeserversChanged = _swig_property(_enigma.eNetworkManager_timeserversChanged_get, _enigma.eNetworkManager_timeserversChanged_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.timeUpdates = new_instancemethod(_enigma.eNetworkManager_timeUpdates, None, eNetworkManager)
eNetworkManager.setTimeUpdates = new_instancemethod(_enigma.eNetworkManager_setTimeUpdates, None, eNetworkManager)
eNetworkManager.getTimeservers = new_instancemethod(_enigma.eNetworkManager_getTimeservers, None, eNetworkManager)
eNetworkManager.setTimeservers = new_instancemethod(_enigma.eNetworkManager_setTimeservers, 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
eNetworkManager.TIME_UPDATES_AUTO = _enigma.cvar.eNetworkManager_TIME_UPDATES_AUTO
eNetworkManager.TIME_UPDATES_MANUAL = _enigma.cvar.eNetworkManager_TIME_UPDATES_MANUAL

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
    WOL_SUCCESS = _enigma.eNetworkService_WOL_SUCCESS
    WOL_ERROR_FOREIGN_INTERFACE = _enigma.eNetworkService_WOL_ERROR_FOREIGN_INTERFACE
    WOL_ERROR_SETUP_FAILED = _enigma.eNetworkService_WOL_ERROR_SETUP_FAILED
    WOL_ERROR_NOT_SUPPORTED = _enigma.eNetworkService_WOL_ERROR_NOT_SUPPORTED
    WOL_ERROR_NO_SUCH_INTERFACE = _enigma.eNetworkService_WOL_ERROR_NO_SUCH_INTERFACE
    WAKE_FLAG_NEVER = _enigma.eNetworkService_WAKE_FLAG_NEVER
    WAKE_FLAG_UNICAST = _enigma.eNetworkService_WAKE_FLAG_UNICAST
    WAKE_FLAG_MULTICAST = _enigma.eNetworkService_WAKE_FLAG_MULTICAST
    WAKE_FLAG_BROADCAST = _enigma.eNetworkService_WAKE_FLAG_BROADCAST
    WAKE_FLAG_ACTIVITY = _enigma.eNetworkService_WAKE_FLAG_ACTIVITY
    WAKE_FLAG_ARP = _enigma.eNetworkService_WAKE_FLAG_ARP
    WAKE_FLAG_MAGIC = _enigma.eNetworkService_WAKE_FLAG_MAGIC
    WAKE_FLAG_MAGIC_SECURE = _enigma.eNetworkService_WAKE_FLAG_MAGIC_SECURE

    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, path):
        """setPath(eNetworkService self, std::string const & path)"""
        return _enigma.eNetworkService_setPath(self, path)


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


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


    def hasWoL(self):
        """hasWoL(eNetworkService self) -> bool"""
        return _enigma.eNetworkService_hasWoL(self)


    def wol(self):
        """wol(eNetworkService self) -> int"""
        return _enigma.eNetworkService_wol(self)


    def setWoL(self, type):
        """setWoL(eNetworkService self, int type) -> int"""
        return _enigma.eNetworkService_setWoL(self, type)


    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, autoconnect):
        """setAutoConnect(eNetworkService self, bool const autoconnect)"""
        return _enigma.eNetworkService_setAutoConnect(self, autoconnect)


    def setIpv4Config(self, ipv4):
        """setIpv4Config(eNetworkService self, PseudoDict ipv4)"""
        return _enigma.eNetworkService_setIpv4Config(self, ipv4)


    def setIpv6Config(self, ipv6):
        """setIpv6Config(eNetworkService self, PseudoDict ipv6)"""
        return _enigma.eNetworkService_setIpv6Config(self, ipv6)


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


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


    def setProxyConfig(self, proxy):
        """setProxyConfig(eNetworkService self, PseudoDict proxy)"""
        return _enigma.eNetworkService_setProxyConfig(self, proxy)


    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.hasWoL = new_instancemethod(_enigma.eNetworkService_hasWoL, None, eNetworkService)
eNetworkService.wol = new_instancemethod(_enigma.eNetworkService_wol, None, eNetworkService)
eNetworkService.setWoL = new_instancemethod(_enigma.eNetworkService_setWoL, 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_BLUETOOTH = _enigma.cvar.eNetworkService_TYPE_BLUETOOTH
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
eNetworkService.WAKE_FLAG_LUT = _enigma.cvar.eNetworkService_WAKE_FLAG_LUT

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_BLUETOOTH = _swig_property(_enigma.eNetworkServicePtr_TYPE_BLUETOOTH_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)
    WAKE_FLAG_LUT = _swig_property(_enigma.eNetworkServicePtr_WAKE_FLAG_LUT_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, path):
        """setPath(eNetworkServicePtr self, std::string const & path)"""
        return _enigma.eNetworkServicePtr_setPath(self, path)


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


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


    def hasWoL(self):
        """hasWoL(eNetworkServicePtr self) -> bool"""
        return _enigma.eNetworkServicePtr_hasWoL(self)


    def wol(self):
        """wol(eNetworkServicePtr self) -> int"""
        return _enigma.eNetworkServicePtr_wol(self)


    def setWoL(self, type):
        """setWoL(eNetworkServicePtr self, int type) -> int"""
        return _enigma.eNetworkServicePtr_setWoL(self, type)


    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, autoconnect):
        """setAutoConnect(eNetworkServicePtr self, bool const autoconnect)"""
        return _enigma.eNetworkServicePtr_setAutoConnect(self, autoconnect)


    def setIpv4Config(self, ipv4):
        """setIpv4Config(eNetworkServicePtr self, PseudoDict ipv4)"""
        return _enigma.eNetworkServicePtr_setIpv4Config(self, ipv4)


    def setIpv6Config(self, ipv6):
        """setIpv6Config(eNetworkServicePtr self, PseudoDict ipv6)"""
        return _enigma.eNetworkServicePtr_setIpv6Config(self, ipv6)


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


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


    def setProxyConfig(self, proxy):
        """setProxyConfig(eNetworkServicePtr self, PseudoDict proxy)"""
        return _enigma.eNetworkServicePtr_setProxyConfig(self, proxy)


    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.hasWoL = new_instancemethod(_enigma.eNetworkServicePtr_hasWoL, None, eNetworkServicePtr)
eNetworkServicePtr.wol = new_instancemethod(_enigma.eNetworkServicePtr_wol, None, eNetworkServicePtr)
eNetworkServicePtr.setWoL = new_instancemethod(_enigma.eNetworkServicePtr_setWoL, 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.__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.pop = new_instancemethod(_enigma.eNetworkServicePtrVector_pop, 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.swap = new_instancemethod(_enigma.eNetworkServicePtrVector_swap, 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.clear = new_instancemethod(_enigma.eNetworkServicePtrVector_clear, None, eNetworkServicePtrVector)
eNetworkServicePtrVector.get_allocator = new_instancemethod(_enigma.eNetworkServicePtrVector_get_allocator, 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, powered):
        """setPowered(eNetworkTechnology self, bool powered)"""
        return _enigma.eNetworkTechnology_setPowered(self, powered)


    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, timeout):
        """setIdleTimeout(eNetworkTechnology self, quint32 timeout)"""
        return _enigma.eNetworkTechnology_setIdleTimeout(self, timeout)


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


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


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


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


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


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


    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, powered):
        """setPowered(eNetworkTechnologyPtr self, bool powered)"""
        return _enigma.eNetworkTechnologyPtr_setPowered(self, powered)


    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, timeout):
        """setIdleTimeout(eNetworkTechnologyPtr self, quint32 timeout)"""
        return _enigma.eNetworkTechnologyPtr_setIdleTimeout(self, timeout)


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


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


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


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


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


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


    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.__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.pop = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_pop, 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.swap = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_swap, 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.clear = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_clear, None, eNetworkTechnologyPtrVector)
eNetworkTechnologyPtrVector.get_allocator = new_instancemethod(_enigma.eNetworkTechnologyPtrVector_get_allocator, 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 eStreamServer(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() -> eStreamServer"""
        return _enigma.eStreamServer_getInstance()

    getInstance = staticmethod(getInstance)
    UPSTREAM_STATE_DISABLED = _enigma.eStreamServer_UPSTREAM_STATE_DISABLED
    UPSTREAM_STATE_CONNECTING = _enigma.eStreamServer_UPSTREAM_STATE_CONNECTING
    UPSTREAM_STATE_WAITING = _enigma.eStreamServer_UPSTREAM_STATE_WAITING
    UPSTREAM_STATE_TRANSMITTING = _enigma.eStreamServer_UPSTREAM_STATE_TRANSMITTING
    UPSTREAM_STATE_OVERLOAD = _enigma.eStreamServer_UPSTREAM_STATE_OVERLOAD
    UPSTREAM_STATE_ADJUSTING = _enigma.eStreamServer_UPSTREAM_STATE_ADJUSTING
    INPUT_MODE_LIVE = _enigma.eStreamServer_INPUT_MODE_LIVE
    INPUT_MODE_HDMI_IN = _enigma.eStreamServer_INPUT_MODE_HDMI_IN
    INPUT_MODE_BACKGROUND = _enigma.eStreamServer_INPUT_MODE_BACKGROUND
    GOP_LENGTH_MIN = _enigma.eStreamServer_GOP_LENGTH_MIN
    GOP_LENGTH_AUTO = _enigma.eStreamServer_GOP_LENGTH_AUTO
    GOP_LENGTH_MAX = _enigma.eStreamServer_GOP_LENGTH_MAX
    PROFILE_MAIN = _enigma.eStreamServer_PROFILE_MAIN
    PROFILE_DEFAULT = _enigma.eStreamServer_PROFILE_DEFAULT
    PROFILE_HIGH = _enigma.eStreamServer_PROFILE_HIGH
    BFRAMES_MIN = _enigma.eStreamServer_BFRAMES_MIN
    BFRAMES_DEFAULT = _enigma.eStreamServer_BFRAMES_DEFAULT
    BFRAMES_MAX = _enigma.eStreamServer_BFRAMES_MAX
    PFRAMES_MIN = _enigma.eStreamServer_PFRAMES_MIN
    PFRAMES_DEFAULT = _enigma.eStreamServer_PFRAMES_DEFAULT
    PFRAMES_MAX = _enigma.eStreamServer_PFRAMES_MAX
    SLICES_MIN = _enigma.eStreamServer_SLICES_MIN
    SLICES_DEFAULT = _enigma.eStreamServer_SLICES_DEFAULT
    SLICES_MAX = _enigma.eStreamServer_SLICES_MAX
    LEVEL1_1 = _enigma.eStreamServer_LEVEL1_1
    LEVEL1_2 = _enigma.eStreamServer_LEVEL1_2
    LEVEL1_3 = _enigma.eStreamServer_LEVEL1_3
    LEVEL2_0 = _enigma.eStreamServer_LEVEL2_0
    LEVEL2_1 = _enigma.eStreamServer_LEVEL2_1
    LEVEL2_2 = _enigma.eStreamServer_LEVEL2_2
    LEVEL3_0 = _enigma.eStreamServer_LEVEL3_0
    LEVEL3_1 = _enigma.eStreamServer_LEVEL3_1
    LEVEL3_2 = _enigma.eStreamServer_LEVEL3_2
    LEVEL4_0 = _enigma.eStreamServer_LEVEL4_0
    LEVEL4_1 = _enigma.eStreamServer_LEVEL4_1
    LEVEL4_2 = _enigma.eStreamServer_LEVEL4_2
    LEVEL_MIN = _enigma.eStreamServer_LEVEL_MIN
    LEVEL_DEFAULT = _enigma.eStreamServer_LEVEL_DEFAULT
    LEVEL_MAX = _enigma.eStreamServer_LEVEL_MAX

    def isAvailable(self):
        """isAvailable(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_isAvailable(self)


    def isRTSPEnabled(self):
        """isRTSPEnabled(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_isRTSPEnabled(self)


    def isHLSEnabled(self):
        """isHLSEnabled(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_isHLSEnabled(self)


    def isUpstreamEnabled(self):
        """isUpstreamEnabled(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_isUpstreamEnabled(self)


    def rtspClientCount(self):
        """rtspClientCount(eStreamServer self) -> int"""
        return _enigma.eStreamServer_rtspClientCount(self)


    def sourceState(self):
        """sourceState(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_sourceState(self)


    def upstreamState(self):
        """upstreamState(eStreamServer self) -> int"""
        return _enigma.eStreamServer_upstreamState(self)


    def rtspState(self):
        """rtspState(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_rtspState(self)


    def hlsState(self):
        """hlsState(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_hlsState(self)


    def width(self):
        """width(eStreamServer self) -> int"""
        return _enigma.eStreamServer_width(self)


    def height(self):
        """height(eStreamServer self) -> int"""
        return _enigma.eStreamServer_height(self)


    def rtspUsername(self):
        """rtspUsername(eStreamServer self) -> std::string"""
        return _enigma.eStreamServer_rtspUsername(self)


    def rtspPassword(self):
        """rtspPassword(eStreamServer self) -> std::string"""
        return _enigma.eStreamServer_rtspPassword(self)


    def rtspPath(self):
        """rtspPath(eStreamServer self) -> std::string"""
        return _enigma.eStreamServer_rtspPath(self)


    def hlsUsername(self):
        """hlsUsername(eStreamServer self) -> std::string"""
        return _enigma.eStreamServer_hlsUsername(self)


    def hlsPassword(self):
        """hlsPassword(eStreamServer self) -> std::string"""
        return _enigma.eStreamServer_hlsPassword(self)


    def hlsPath(self):
        """hlsPath(eStreamServer self) -> std::string"""
        return _enigma.eStreamServer_hlsPath(self)


    def uriParameters(self):
        """uriParameters(eStreamServer self) -> std::string"""
        return _enigma.eStreamServer_uriParameters(self)


    def inputMode(self):
        """inputMode(eStreamServer self) -> int"""
        return _enigma.eStreamServer_inputMode(self)


    def setInputMode(self, value):
        """setInputMode(eStreamServer self, int value)"""
        return _enigma.eStreamServer_setInputMode(self, value)


    def audioBitrate(self):
        """audioBitrate(eStreamServer self) -> int"""
        return _enigma.eStreamServer_audioBitrate(self)


    def setAudioBitrate(self, value):
        """setAudioBitrate(eStreamServer self, int value)"""
        return _enigma.eStreamServer_setAudioBitrate(self, value)


    def videoBitrate(self):
        """videoBitrate(eStreamServer self) -> int"""
        return _enigma.eStreamServer_videoBitrate(self)


    def setVideoBitrate(self, value):
        """setVideoBitrate(eStreamServer self, int value)"""
        return _enigma.eStreamServer_setVideoBitrate(self, value)


    def autoBitrate(self):
        """autoBitrate(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_autoBitrate(self)


    def setAutoBitrate(self, value):
        """setAutoBitrate(eStreamServer self, bool value)"""
        return _enigma.eStreamServer_setAutoBitrate(self, value)


    def gopLength(self):
        """gopLength(eStreamServer self) -> int"""
        return _enigma.eStreamServer_gopLength(self)


    def setGopLength(self, value):
        """setGopLength(eStreamServer self, int value)"""
        return _enigma.eStreamServer_setGopLength(self, value)


    def gopOnSceneChange(self):
        """gopOnSceneChange(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_gopOnSceneChange(self)


    def setGopOnSceneChange(self, enabled):
        """setGopOnSceneChange(eStreamServer self, bool enabled)"""
        return _enigma.eStreamServer_setGopOnSceneChange(self, enabled)


    def openGop(self):
        """openGop(eStreamServer self) -> bool"""
        return _enigma.eStreamServer_openGop(self)


    def setOpenGop(self, enabled):
        """setOpenGop(eStreamServer self, bool enabled)"""
        return _enigma.eStreamServer_setOpenGop(self, enabled)


    def bFrames(self):
        """bFrames(eStreamServer self) -> int"""
        return _enigma.eStreamServer_bFrames(self)


    def setBFrames(self, bFrames):
        """setBFrames(eStreamServer self, int bFrames)"""
        return _enigma.eStreamServer_setBFrames(self, bFrames)


    def pFrames(self):
        """pFrames(eStreamServer self) -> int"""
        return _enigma.eStreamServer_pFrames(self)


    def setPFrames(self, pFrames):
        """setPFrames(eStreamServer self, int pFrames)"""
        return _enigma.eStreamServer_setPFrames(self, pFrames)


    def slices(self):
        """slices(eStreamServer self) -> int"""
        return _enigma.eStreamServer_slices(self)


    def setSlices(self, slices):
        """setSlices(eStreamServer self, int slices)"""
        return _enigma.eStreamServer_setSlices(self, slices)


    def level(self):
        """level(eStreamServer self) -> int"""
        return _enigma.eStreamServer_level(self)


    def setLevel(self, level):
        """setLevel(eStreamServer self, int level)"""
        return _enigma.eStreamServer_setLevel(self, level)


    def profile(self):
        """profile(eStreamServer self) -> int"""
        return _enigma.eStreamServer_profile(self)


    def setProfile(self, profile):
        """setProfile(eStreamServer self, int profile)"""
        return _enigma.eStreamServer_setProfile(self, profile)


    def framerate(self):
        """framerate(eStreamServer self) -> int"""
        return _enigma.eStreamServer_framerate(self)


    def setFramerate(self, value):
        """setFramerate(eStreamServer self, int value)"""
        return _enigma.eStreamServer_setFramerate(self, value)


    def enableRTSP(self, *args):
        """
        enableRTSP(eStreamServer self, bool state, std::string const & path, uint32_t port=554, std::string const & user, std::string const & arg6) -> bool
        enableRTSP(eStreamServer self, bool state, std::string const & path, uint32_t port=554, std::string const & user) -> bool
        enableRTSP(eStreamServer self, bool state, std::string const & path, uint32_t port=554) -> bool
        enableRTSP(eStreamServer self, bool state, std::string const & path) -> bool
        enableRTSP(eStreamServer self, bool state) -> bool
        """
        return _enigma.eStreamServer_enableRTSP(self, *args)


    def enableHLS(self, *args):
        """
        enableHLS(eStreamServer self, bool state, std::string const & path, uint32_t port=8080, std::string const & user, std::string const & arg6) -> bool
        enableHLS(eStreamServer self, bool state, std::string const & path, uint32_t port=8080, std::string const & user) -> bool
        enableHLS(eStreamServer self, bool state, std::string const & path, uint32_t port=8080) -> bool
        enableHLS(eStreamServer self, bool state, std::string const & path) -> bool
        enableHLS(eStreamServer self, bool state) -> bool
        """
        return _enigma.eStreamServer_enableHLS(self, *args)


    def enableUpstream(self, state, host, port, token):
        """enableUpstream(eStreamServer self, bool state, std::string const & host, uint32_t port, std::string const & token) -> bool"""
        return _enigma.eStreamServer_enableUpstream(self, state, host, port, token)


    def setResolution(self, width, height):
        """setResolution(eStreamServer self, int width, int height)"""
        return _enigma.eStreamServer_setResolution(self, width, height)

    availabilityChanged = _swig_property(_enigma.eStreamServer_availabilityChanged_get, _enigma.eStreamServer_availabilityChanged_set)
    sourceStateChanged = _swig_property(_enigma.eStreamServer_sourceStateChanged_get, _enigma.eStreamServer_sourceStateChanged_set)
    upstreamStateChanged = _swig_property(_enigma.eStreamServer_upstreamStateChanged_get, _enigma.eStreamServer_upstreamStateChanged_set)
    upstreamBitrateChanged = _swig_property(_enigma.eStreamServer_upstreamBitrateChanged_get, _enigma.eStreamServer_upstreamBitrateChanged_set)
    rtspClientCountChanged = _swig_property(_enigma.eStreamServer_rtspClientCountChanged_get, _enigma.eStreamServer_rtspClientCountChanged_set)
    rtspStateChanged = _swig_property(_enigma.eStreamServer_rtspStateChanged_get, _enigma.eStreamServer_rtspStateChanged_set)
    hlsStateChanged = _swig_property(_enigma.eStreamServer_hlsStateChanged_get, _enigma.eStreamServer_hlsStateChanged_set)
    uriParametersChanged = _swig_property(_enigma.eStreamServer_uriParametersChanged_get, _enigma.eStreamServer_uriParametersChanged_set)
    dbusError = _swig_property(_enigma.eStreamServer_dbusError_get, _enigma.eStreamServer_dbusError_set)
    ping = _swig_property(_enigma.eStreamServer_ping_get, _enigma.eStreamServer_ping_set)
eStreamServer.isAvailable = new_instancemethod(_enigma.eStreamServer_isAvailable, None, eStreamServer)
eStreamServer.isRTSPEnabled = new_instancemethod(_enigma.eStreamServer_isRTSPEnabled, None, eStreamServer)
eStreamServer.isHLSEnabled = new_instancemethod(_enigma.eStreamServer_isHLSEnabled, None, eStreamServer)
eStreamServer.isUpstreamEnabled = new_instancemethod(_enigma.eStreamServer_isUpstreamEnabled, None, eStreamServer)
eStreamServer.rtspClientCount = new_instancemethod(_enigma.eStreamServer_rtspClientCount, None, eStreamServer)
eStreamServer.sourceState = new_instancemethod(_enigma.eStreamServer_sourceState, None, eStreamServer)
eStreamServer.upstreamState = new_instancemethod(_enigma.eStreamServer_upstreamState, None, eStreamServer)
eStreamServer.rtspState = new_instancemethod(_enigma.eStreamServer_rtspState, None, eStreamServer)
eStreamServer.hlsState = new_instancemethod(_enigma.eStreamServer_hlsState, None, eStreamServer)
eStreamServer.width = new_instancemethod(_enigma.eStreamServer_width, None, eStreamServer)
eStreamServer.height = new_instancemethod(_enigma.eStreamServer_height, None, eStreamServer)
eStreamServer.rtspUsername = new_instancemethod(_enigma.eStreamServer_rtspUsername, None, eStreamServer)
eStreamServer.rtspPassword = new_instancemethod(_enigma.eStreamServer_rtspPassword, None, eStreamServer)
eStreamServer.rtspPath = new_instancemethod(_enigma.eStreamServer_rtspPath, None, eStreamServer)
eStreamServer.hlsUsername = new_instancemethod(_enigma.eStreamServer_hlsUsername, None, eStreamServer)
eStreamServer.hlsPassword = new_instancemethod(_enigma.eStreamServer_hlsPassword, None, eStreamServer)
eStreamServer.hlsPath = new_instancemethod(_enigma.eStreamServer_hlsPath, None, eStreamServer)
eStreamServer.uriParameters = new_instancemethod(_enigma.eStreamServer_uriParameters, None, eStreamServer)
eStreamServer.inputMode = new_instancemethod(_enigma.eStreamServer_inputMode, None, eStreamServer)
eStreamServer.setInputMode = new_instancemethod(_enigma.eStreamServer_setInputMode, None, eStreamServer)
eStreamServer.audioBitrate = new_instancemethod(_enigma.eStreamServer_audioBitrate, None, eStreamServer)
eStreamServer.setAudioBitrate = new_instancemethod(_enigma.eStreamServer_setAudioBitrate, None, eStreamServer)
eStreamServer.videoBitrate = new_instancemethod(_enigma.eStreamServer_videoBitrate, None, eStreamServer)
eStreamServer.setVideoBitrate = new_instancemethod(_enigma.eStreamServer_setVideoBitrate, None, eStreamServer)
eStreamServer.autoBitrate = new_instancemethod(_enigma.eStreamServer_autoBitrate, None, eStreamServer)
eStreamServer.setAutoBitrate = new_instancemethod(_enigma.eStreamServer_setAutoBitrate, None, eStreamServer)
eStreamServer.gopLength = new_instancemethod(_enigma.eStreamServer_gopLength, None, eStreamServer)
eStreamServer.setGopLength = new_instancemethod(_enigma.eStreamServer_setGopLength, None, eStreamServer)
eStreamServer.gopOnSceneChange = new_instancemethod(_enigma.eStreamServer_gopOnSceneChange, None, eStreamServer)
eStreamServer.setGopOnSceneChange = new_instancemethod(_enigma.eStreamServer_setGopOnSceneChange, None, eStreamServer)
eStreamServer.openGop = new_instancemethod(_enigma.eStreamServer_openGop, None, eStreamServer)
eStreamServer.setOpenGop = new_instancemethod(_enigma.eStreamServer_setOpenGop, None, eStreamServer)
eStreamServer.bFrames = new_instancemethod(_enigma.eStreamServer_bFrames, None, eStreamServer)
eStreamServer.setBFrames = new_instancemethod(_enigma.eStreamServer_setBFrames, None, eStreamServer)
eStreamServer.pFrames = new_instancemethod(_enigma.eStreamServer_pFrames, None, eStreamServer)
eStreamServer.setPFrames = new_instancemethod(_enigma.eStreamServer_setPFrames, None, eStreamServer)
eStreamServer.slices = new_instancemethod(_enigma.eStreamServer_slices, None, eStreamServer)
eStreamServer.setSlices = new_instancemethod(_enigma.eStreamServer_setSlices, None, eStreamServer)
eStreamServer.level = new_instancemethod(_enigma.eStreamServer_level, None, eStreamServer)
eStreamServer.setLevel = new_instancemethod(_enigma.eStreamServer_setLevel, None, eStreamServer)
eStreamServer.profile = new_instancemethod(_enigma.eStreamServer_profile, None, eStreamServer)
eStreamServer.setProfile = new_instancemethod(_enigma.eStreamServer_setProfile, None, eStreamServer)
eStreamServer.framerate = new_instancemethod(_enigma.eStreamServer_framerate, None, eStreamServer)
eStreamServer.setFramerate = new_instancemethod(_enigma.eStreamServer_setFramerate, None, eStreamServer)
eStreamServer.enableRTSP = new_instancemethod(_enigma.eStreamServer_enableRTSP, None, eStreamServer)
eStreamServer.enableHLS = new_instancemethod(_enigma.eStreamServer_enableHLS, None, eStreamServer)
eStreamServer.enableUpstream = new_instancemethod(_enigma.eStreamServer_enableUpstream, None, eStreamServer)
eStreamServer.setResolution = new_instancemethod(_enigma.eStreamServer_setResolution, None, eStreamServer)
eStreamServer_swigregister = _enigma.eStreamServer_swigregister
eStreamServer_swigregister(eStreamServer)

def eStreamServer_getInstance():
    """eStreamServer_getInstance() -> eStreamServer"""
    return _enigma.eStreamServer_getInstance()

class eVideoMode(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    height = _swig_property(_enigma.eVideoMode_height_get, _enigma.eVideoMode_height_set)
    width = _swig_property(_enigma.eVideoMode_width_get, _enigma.eVideoMode_width_set)
    lineMode = _swig_property(_enigma.eVideoMode_lineMode_get, _enigma.eVideoMode_lineMode_set)
    rate = _swig_property(_enigma.eVideoMode_rate_get, _enigma.eVideoMode_rate_set)
    preferred = _swig_property(_enigma.eVideoMode_preferred_get, _enigma.eVideoMode_preferred_set)
    name = _swig_property(_enigma.eVideoMode_name_get, _enigma.eVideoMode_name_set)
    value = _swig_property(_enigma.eVideoMode_value_get, _enigma.eVideoMode_value_set)

    def __init__(self):
        """__init__(_eVideoMode self) -> eVideoMode"""
        _enigma.eVideoMode_swiginit(self, _enigma.new_eVideoMode())
    __swig_destroy__ = _enigma.delete_eVideoMode
eVideoMode_swigregister = _enigma.eVideoMode_swigregister
eVideoMode_swigregister(eVideoMode)

class eVideoPort(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    modes = _swig_property(_enigma.eVideoPort_modes_get, _enigma.eVideoPort_modes_set)
    modesPreferred = _swig_property(_enigma.eVideoPort_modesPreferred_get, _enigma.eVideoPort_modesPreferred_set)

    def __init__(self):
        """__init__(_eVideoPort self) -> eVideoPort"""
        _enigma.eVideoPort_swiginit(self, _enigma.new_eVideoPort())
    __swig_destroy__ = _enigma.delete_eVideoPort
eVideoPort_swigregister = _enigma.eVideoPort_swigregister
eVideoPort_swigregister(eVideoPort)

class ePropertyRange(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    min = _swig_property(_enigma.ePropertyRange_min_get, _enigma.ePropertyRange_min_set)
    max = _swig_property(_enigma.ePropertyRange_max_get, _enigma.ePropertyRange_max_set)
    defaultValue = _swig_property(_enigma.ePropertyRange_defaultValue_get, _enigma.ePropertyRange_defaultValue_set)

    def __init__(self):
        """__init__(_ePropertyRange self) -> ePropertyRange"""
        _enigma.ePropertyRange_swiginit(self, _enigma.new_ePropertyRange())
    __swig_destroy__ = _enigma.delete_ePropertyRange
ePropertyRange_swigregister = _enigma.ePropertyRange_swigregister
ePropertyRange_swigregister(ePropertyRange)

class eDisplayManager(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 assignEventRelay(self, event):
        """assignEventRelay(eDisplayManager self, eSignal1I event)"""
        return _enigma.eDisplayManager_assignEventRelay(self, event)


    def getInstance():
        """getInstance() -> eDisplayManager"""
        return _enigma.eDisplayManager_getInstance()

    getInstance = staticmethod(getInstance)

    def isWidescreen(mode):
        """isWidescreen(std::string const & mode) -> bool"""
        return _enigma.eDisplayManager_isWidescreen(mode)

    isWidescreen = staticmethod(isWidescreen)

    def getCurrentContentFramerate():
        """getCurrentContentFramerate() -> int"""
        return _enigma.eDisplayManager_getCurrentContentFramerate()

    getCurrentContentFramerate = staticmethod(getCurrentContentFramerate)

    def getCurrentContentSize(width, height, aspect):
        """getCurrentContentSize(int & width, int & height, int & aspect) -> int"""
        return _enigma.eDisplayManager_getCurrentContentSize(width, height, aspect)

    getCurrentContentSize = staticmethod(getCurrentContentSize)
    PORT_HDMI = _enigma.eDisplayManager_PORT_HDMI
    PORT_HDMI_PC = _enigma.eDisplayManager_PORT_HDMI_PC
    ASPECT_ANY = _enigma.eDisplayManager_ASPECT_ANY
    ASPECT_4_3 = _enigma.eDisplayManager_ASPECT_4_3
    ASPECT_16_9 = _enigma.eDisplayManager_ASPECT_16_9
    ASPECT_16_10 = _enigma.eDisplayManager_ASPECT_16_10
    LM_PROGRESSIVE = _enigma.eDisplayManager_LM_PROGRESSIVE
    LM_INTERLACED = _enigma.eDisplayManager_LM_INTERLACED
    RATE_23_976HZ = _enigma.eDisplayManager_RATE_23_976HZ
    RATE_24HZ = _enigma.eDisplayManager_RATE_24HZ
    RATE_25HZ = _enigma.eDisplayManager_RATE_25HZ
    RATE_29_970HZ = _enigma.eDisplayManager_RATE_29_970HZ
    RATE_30HZ = _enigma.eDisplayManager_RATE_30HZ
    RATE_50HZ = _enigma.eDisplayManager_RATE_50HZ
    RATE_59_940HZ = _enigma.eDisplayManager_RATE_59_940HZ
    RATE_60HZ = _enigma.eDisplayManager_RATE_60HZ
    RATE_AUTO = _enigma.eDisplayManager_RATE_AUTO
    PM_LETTERBOX = _enigma.eDisplayManager_PM_LETTERBOX
    PM_PILLARBOX = _enigma.eDisplayManager_PM_PILLARBOX
    PM_PANSCAN = _enigma.eDisplayManager_PM_PANSCAN
    PM_NONLINEAR = _enigma.eDisplayManager_PM_NONLINEAR
    PM_BESTFIT = _enigma.eDisplayManager_PM_BESTFIT
    PM_POLICY = _enigma.eDisplayManager_PM_POLICY
    PM_COMBINED = _enigma.eDisplayManager_PM_COMBINED
    HLG_FORCE_ON = _enigma.eDisplayManager_HLG_FORCE_ON
    HLG_FORCE_OFF = _enigma.eDisplayManager_HLG_FORCE_OFF
    HLG_AUTO = _enigma.eDisplayManager_HLG_AUTO
    HDR_FORCE_ON = _enigma.eDisplayManager_HDR_FORCE_ON
    HDR_FORCE_OFF = _enigma.eDisplayManager_HDR_FORCE_OFF
    HDR_AUTO = _enigma.eDisplayManager_HDR_AUTO
    PROPERTY_DISABLED = _enigma.eDisplayManager_PROPERTY_DISABLED
    PROPERTY_ENABLED = _enigma.eDisplayManager_PROPERTY_ENABLED

    def load(self):
        """load(eDisplayManager self)"""
        return _enigma.eDisplayManager_load(self)


    def getAvailablePorts(self, INOUT):
        """getAvailablePorts(eDisplayManager self, eVideoPorts INOUT)"""
        return _enigma.eDisplayManager_getAvailablePorts(self, INOUT)


    def getAvailableAspects(self, INOUT):
        """getAvailableAspects(eDisplayManager self, IntList INOUT)"""
        return _enigma.eDisplayManager_getAvailableAspects(self, INOUT)


    def getAvailableStandardPolicies(self, INOUT):
        """getAvailableStandardPolicies(eDisplayManager self, IntList INOUT)"""
        return _enigma.eDisplayManager_getAvailableStandardPolicies(self, INOUT)


    def getAvailableWidescreenPolicies(self, INOUT):
        """getAvailableWidescreenPolicies(eDisplayManager self, IntList INOUT)"""
        return _enigma.eDisplayManager_getAvailableWidescreenPolicies(self, INOUT)


    def getAvailableHLGSupportModes(self, INOUT):
        """getAvailableHLGSupportModes(eDisplayManager self, IntList INOUT)"""
        return _enigma.eDisplayManager_getAvailableHLGSupportModes(self, INOUT)


    def getAvailableHDR10SupportModes(self, INOUT):
        """getAvailableHDR10SupportModes(eDisplayManager self, IntList INOUT)"""
        return _enigma.eDisplayManager_getAvailableHDR10SupportModes(self, INOUT)


    def getAvailableHDR10BitModes(self, INOUT):
        """getAvailableHDR10BitModes(eDisplayManager self, IntList INOUT)"""
        return _enigma.eDisplayManager_getAvailableHDR10BitModes(self, INOUT)


    def getAvailableHDR12BitModes(self, INOUT):
        """getAvailableHDR12BitModes(eDisplayManager self, IntList INOUT)"""
        return _enigma.eDisplayManager_getAvailableHDR12BitModes(self, INOUT)


    def getCurrentMode(self):
        """getCurrentMode(eDisplayManager self) -> eVideoMode"""
        return _enigma.eDisplayManager_getCurrentMode(self)


    def setCurrentMode(self, mode):
        """setCurrentMode(eDisplayManager self, eVideoMode mode)"""
        return _enigma.eDisplayManager_setCurrentMode(self, mode)


    def getAspect(self):
        """getAspect(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getAspect(self)


    def setAspect(self, aspect):
        """setAspect(eDisplayManager self, int aspect)"""
        return _enigma.eDisplayManager_setAspect(self, aspect)


    def setPolicies(self, standard, widescreen):
        """setPolicies(eDisplayManager self, int standard, int widescreen)"""
        return _enigma.eDisplayManager_setPolicies(self, standard, widescreen)


    def getStandardPolicy(self):
        """getStandardPolicy(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getStandardPolicy(self)


    def getWidescreenPolicy(self):
        """getWidescreenPolicy(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getWidescreenPolicy(self)


    def hasOSDAlpha(self):
        """hasOSDAlpha(eDisplayManager self) -> bool"""
        return _enigma.eDisplayManager_hasOSDAlpha(self)


    def getOSDAlpha(self):
        """getOSDAlpha(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getOSDAlpha(self)


    def setOSDAlpha(self, alpha):
        """setOSDAlpha(eDisplayManager self, int alpha)"""
        return _enigma.eDisplayManager_setOSDAlpha(self, alpha)


    def hasScalerSharpness(self):
        """hasScalerSharpness(eDisplayManager self) -> bool"""
        return _enigma.eDisplayManager_hasScalerSharpness(self)


    def getScalerSharpness(self):
        """getScalerSharpness(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getScalerSharpness(self)


    def setScalerSharpness(self, sharpness):
        """setScalerSharpness(eDisplayManager self, int sharpness)"""
        return _enigma.eDisplayManager_setScalerSharpness(self, sharpness)


    def hasHDRSupport(self):
        """hasHDRSupport(eDisplayManager self) -> bool"""
        return _enigma.eDisplayManager_hasHDRSupport(self)


    def getHLGSupport(self):
        """getHLGSupport(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getHLGSupport(self)


    def setHLGSupport(self, mode):
        """setHLGSupport(eDisplayManager self, int mode)"""
        return _enigma.eDisplayManager_setHLGSupport(self, mode)


    def getHDR10Support(self):
        """getHDR10Support(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getHDR10Support(self)


    def setHDR10Support(self, mode):
        """setHDR10Support(eDisplayManager self, int mode)"""
        return _enigma.eDisplayManager_setHDR10Support(self, mode)


    def getHDR10Bit(self):
        """getHDR10Bit(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getHDR10Bit(self)


    def setHDR10Bit(self, enabled):
        """setHDR10Bit(eDisplayManager self, int enabled)"""
        return _enigma.eDisplayManager_setHDR10Bit(self, enabled)


    def getHDR12Bit(self):
        """getHDR12Bit(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getHDR12Bit(self)


    def setHDR12Bit(self, enabled):
        """setHDR12Bit(eDisplayManager self, int enabled)"""
        return _enigma.eDisplayManager_setHDR12Bit(self, enabled)


    def setPIGMode(self, active):
        """setPIGMode(eDisplayManager self, bool active)"""
        return _enigma.eDisplayManager_setPIGMode(self, active)


    def getAspectDefault(self):
        """getAspectDefault(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getAspectDefault(self)


    def getStandardPolicyDefault(self):
        """getStandardPolicyDefault(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getStandardPolicyDefault(self)


    def getWidescreenPolicyDefault(self):
        """getWidescreenPolicyDefault(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getWidescreenPolicyDefault(self)


    def getOSDAlphaRange(self):
        """getOSDAlphaRange(eDisplayManager self) -> ePropertyRange"""
        return _enigma.eDisplayManager_getOSDAlphaRange(self)


    def getScalerSharpnessRange(self):
        """getScalerSharpnessRange(eDisplayManager self) -> ePropertyRange"""
        return _enigma.eDisplayManager_getScalerSharpnessRange(self)


    def getHLGSupportDefault(self):
        """getHLGSupportDefault(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getHLGSupportDefault(self)


    def getHDR10SupportDefault(self):
        """getHDR10SupportDefault(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getHDR10SupportDefault(self)


    def getHDR10BitDefault(self):
        """getHDR10BitDefault(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getHDR10BitDefault(self)


    def getHDR12BitDefault(self):
        """getHDR12BitDefault(eDisplayManager self) -> int"""
        return _enigma.eDisplayManager_getHDR12BitDefault(self)

    modeChanged = _swig_property(_enigma.eDisplayManager_modeChanged_get, _enigma.eDisplayManager_modeChanged_set)
    contentSizeChanged = _swig_property(_enigma.eDisplayManager_contentSizeChanged_get, _enigma.eDisplayManager_contentSizeChanged_set)
    contentFramerateChanged = _swig_property(_enigma.eDisplayManager_contentFramerateChanged_get, _enigma.eDisplayManager_contentFramerateChanged_set)
    contentPtsValid = _swig_property(_enigma.eDisplayManager_contentPtsValid_get, _enigma.eDisplayManager_contentPtsValid_set)
    hdmiChanged = _swig_property(_enigma.eDisplayManager_hdmiChanged_get, _enigma.eDisplayManager_hdmiChanged_set)
eDisplayManager.assignEventRelay = new_instancemethod(_enigma.eDisplayManager_assignEventRelay, None, eDisplayManager)
eDisplayManager.load = new_instancemethod(_enigma.eDisplayManager_load, None, eDisplayManager)
eDisplayManager.getAvailablePorts = new_instancemethod(_enigma.eDisplayManager_getAvailablePorts, None, eDisplayManager)
eDisplayManager.getAvailableAspects = new_instancemethod(_enigma.eDisplayManager_getAvailableAspects, None, eDisplayManager)
eDisplayManager.getAvailableStandardPolicies = new_instancemethod(_enigma.eDisplayManager_getAvailableStandardPolicies, None, eDisplayManager)
eDisplayManager.getAvailableWidescreenPolicies = new_instancemethod(_enigma.eDisplayManager_getAvailableWidescreenPolicies, None, eDisplayManager)
eDisplayManager.getAvailableHLGSupportModes = new_instancemethod(_enigma.eDisplayManager_getAvailableHLGSupportModes, None, eDisplayManager)
eDisplayManager.getAvailableHDR10SupportModes = new_instancemethod(_enigma.eDisplayManager_getAvailableHDR10SupportModes, None, eDisplayManager)
eDisplayManager.getAvailableHDR10BitModes = new_instancemethod(_enigma.eDisplayManager_getAvailableHDR10BitModes, None, eDisplayManager)
eDisplayManager.getAvailableHDR12BitModes = new_instancemethod(_enigma.eDisplayManager_getAvailableHDR12BitModes, None, eDisplayManager)
eDisplayManager.getCurrentMode = new_instancemethod(_enigma.eDisplayManager_getCurrentMode, None, eDisplayManager)
eDisplayManager.setCurrentMode = new_instancemethod(_enigma.eDisplayManager_setCurrentMode, None, eDisplayManager)
eDisplayManager.getAspect = new_instancemethod(_enigma.eDisplayManager_getAspect, None, eDisplayManager)
eDisplayManager.setAspect = new_instancemethod(_enigma.eDisplayManager_setAspect, None, eDisplayManager)
eDisplayManager.setPolicies = new_instancemethod(_enigma.eDisplayManager_setPolicies, None, eDisplayManager)
eDisplayManager.getStandardPolicy = new_instancemethod(_enigma.eDisplayManager_getStandardPolicy, None, eDisplayManager)
eDisplayManager.getWidescreenPolicy = new_instancemethod(_enigma.eDisplayManager_getWidescreenPolicy, None, eDisplayManager)
eDisplayManager.hasOSDAlpha = new_instancemethod(_enigma.eDisplayManager_hasOSDAlpha, None, eDisplayManager)
eDisplayManager.getOSDAlpha = new_instancemethod(_enigma.eDisplayManager_getOSDAlpha, None, eDisplayManager)
eDisplayManager.setOSDAlpha = new_instancemethod(_enigma.eDisplayManager_setOSDAlpha, None, eDisplayManager)
eDisplayManager.hasScalerSharpness = new_instancemethod(_enigma.eDisplayManager_hasScalerSharpness, None, eDisplayManager)
eDisplayManager.getScalerSharpness = new_instancemethod(_enigma.eDisplayManager_getScalerSharpness, None, eDisplayManager)
eDisplayManager.setScalerSharpness = new_instancemethod(_enigma.eDisplayManager_setScalerSharpness, None, eDisplayManager)
eDisplayManager.hasHDRSupport = new_instancemethod(_enigma.eDisplayManager_hasHDRSupport, None, eDisplayManager)
eDisplayManager.getHLGSupport = new_instancemethod(_enigma.eDisplayManager_getHLGSupport, None, eDisplayManager)
eDisplayManager.setHLGSupport = new_instancemethod(_enigma.eDisplayManager_setHLGSupport, None, eDisplayManager)
eDisplayManager.getHDR10Support = new_instancemethod(_enigma.eDisplayManager_getHDR10Support, None, eDisplayManager)
eDisplayManager.setHDR10Support = new_instancemethod(_enigma.eDisplayManager_setHDR10Support, None, eDisplayManager)
eDisplayManager.getHDR10Bit = new_instancemethod(_enigma.eDisplayManager_getHDR10Bit, None, eDisplayManager)
eDisplayManager.setHDR10Bit = new_instancemethod(_enigma.eDisplayManager_setHDR10Bit, None, eDisplayManager)
eDisplayManager.getHDR12Bit = new_instancemethod(_enigma.eDisplayManager_getHDR12Bit, None, eDisplayManager)
eDisplayManager.setHDR12Bit = new_instancemethod(_enigma.eDisplayManager_setHDR12Bit, None, eDisplayManager)
eDisplayManager.setPIGMode = new_instancemethod(_enigma.eDisplayManager_setPIGMode, None, eDisplayManager)
eDisplayManager.getAspectDefault = new_instancemethod(_enigma.eDisplayManager_getAspectDefault, None, eDisplayManager)
eDisplayManager.getStandardPolicyDefault = new_instancemethod(_enigma.eDisplayManager_getStandardPolicyDefault, None, eDisplayManager)
eDisplayManager.getWidescreenPolicyDefault = new_instancemethod(_enigma.eDisplayManager_getWidescreenPolicyDefault, None, eDisplayManager)
eDisplayManager.getOSDAlphaRange = new_instancemethod(_enigma.eDisplayManager_getOSDAlphaRange, None, eDisplayManager)
eDisplayManager.getScalerSharpnessRange = new_instancemethod(_enigma.eDisplayManager_getScalerSharpnessRange, None, eDisplayManager)
eDisplayManager.getHLGSupportDefault = new_instancemethod(_enigma.eDisplayManager_getHLGSupportDefault, None, eDisplayManager)
eDisplayManager.getHDR10SupportDefault = new_instancemethod(_enigma.eDisplayManager_getHDR10SupportDefault, None, eDisplayManager)
eDisplayManager.getHDR10BitDefault = new_instancemethod(_enigma.eDisplayManager_getHDR10BitDefault, None, eDisplayManager)
eDisplayManager.getHDR12BitDefault = new_instancemethod(_enigma.eDisplayManager_getHDR12BitDefault, None, eDisplayManager)
eDisplayManager_swigregister = _enigma.eDisplayManager_swigregister
eDisplayManager_swigregister(eDisplayManager)

def eDisplayManager_getInstance():
    """eDisplayManager_getInstance() -> eDisplayManager"""
    return _enigma.eDisplayManager_getInstance()

def eDisplayManager_isWidescreen(mode):
    """eDisplayManager_isWidescreen(std::string const & mode) -> bool"""
    return _enigma.eDisplayManager_isWidescreen(mode)

def eDisplayManager_getCurrentContentFramerate():
    """eDisplayManager_getCurrentContentFramerate() -> int"""
    return _enigma.eDisplayManager_getCurrentContentFramerate()

def eDisplayManager_getCurrentContentSize(width, height, aspect):
    """eDisplayManager_getCurrentContentSize(int & width, int & height, int & aspect) -> int"""
    return _enigma.eDisplayManager_getCurrentContentSize(width, height, aspect)

class eVideoManager(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() -> eVideoManager"""
        return _enigma.eVideoManager_getInstance()

    getInstance = staticmethod(getInstance)
    SM_OFF = _enigma.eVideoManager_SM_OFF
    SM_LEFT = _enigma.eVideoManager_SM_LEFT
    SM_RIGHT = _enigma.eVideoManager_SM_RIGHT
    DM_OFF = _enigma.eVideoManager_DM_OFF
    DM_ON = _enigma.eVideoManager_DM_ON
    DM_AUTO = _enigma.eVideoManager_DM_AUTO
    DM_BOB = _enigma.eVideoManager_DM_BOB

    def load(self):
        """load(eVideoManager self)"""
        return _enigma.eVideoManager_load(self)


    def getAvailableSplitModes(self, INOUT):
        """getAvailableSplitModes(eVideoManager self, IntList INOUT)"""
        return _enigma.eVideoManager_getAvailableSplitModes(self, INOUT)


    def getAvailableDeinterlaceModes(self, INOUT):
        """getAvailableDeinterlaceModes(eVideoManager self, IntList INOUT)"""
        return _enigma.eVideoManager_getAvailableDeinterlaceModes(self, INOUT)


    def hasContrast(self):
        """hasContrast(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasContrast(self)


    def getContrast(self):
        """getContrast(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getContrast(self)


    def setContrast(self, contrast):
        """setContrast(eVideoManager self, int contrast)"""
        return _enigma.eVideoManager_setContrast(self, contrast)


    def hasSaturation(self):
        """hasSaturation(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasSaturation(self)


    def getSaturation(self):
        """getSaturation(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getSaturation(self)


    def setSaturation(self, saturation):
        """setSaturation(eVideoManager self, int saturation)"""
        return _enigma.eVideoManager_setSaturation(self, saturation)


    def hasHue(self):
        """hasHue(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasHue(self)


    def getHue(self):
        """getHue(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getHue(self)


    def setHue(self, hue):
        """setHue(eVideoManager self, int hue)"""
        return _enigma.eVideoManager_setHue(self, hue)


    def hasBrightness(self):
        """hasBrightness(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasBrightness(self)


    def getBrightness(self):
        """getBrightness(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getBrightness(self)


    def setBrightness(self, brightness):
        """setBrightness(eVideoManager self, int brightness)"""
        return _enigma.eVideoManager_setBrightness(self, brightness)


    def hasColorTemp(self):
        """hasColorTemp(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasColorTemp(self)


    def getColorTemp(self):
        """getColorTemp(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getColorTemp(self)


    def setColorTemp(self, colortemp):
        """setColorTemp(eVideoManager self, int const colortemp)"""
        return _enigma.eVideoManager_setColorTemp(self, colortemp)


    def hasScalerSharpness(self):
        """hasScalerSharpness(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasScalerSharpness(self)


    def getScalerSharpness(self):
        """getScalerSharpness(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getScalerSharpness(self)


    def setScalerSharpness(self, sharpness):
        """setScalerSharpness(eVideoManager self, int sharpness)"""
        return _enigma.eVideoManager_setScalerSharpness(self, sharpness)


    def hasSplitMode(self):
        """hasSplitMode(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasSplitMode(self)


    def getSplitMode(self):
        """getSplitMode(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getSplitMode(self)


    def setSplitMode(self, mode):
        """setSplitMode(eVideoManager self, int mode)"""
        return _enigma.eVideoManager_setSplitMode(self, mode)


    def hasSharpness(self):
        """hasSharpness(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasSharpness(self)


    def getSharpness(self):
        """getSharpness(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getSharpness(self)


    def setSharpness(self, sharpness):
        """setSharpness(eVideoManager self, int sharpness)"""
        return _enigma.eVideoManager_setSharpness(self, sharpness)


    def hasAutoFlesh(self):
        """hasAutoFlesh(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasAutoFlesh(self)


    def getAutoFlesh(self):
        """getAutoFlesh(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getAutoFlesh(self)


    def setAutoFlesh(self, level):
        """setAutoFlesh(eVideoManager self, int level)"""
        return _enigma.eVideoManager_setAutoFlesh(self, level)


    def hasGreenBoost(self):
        """hasGreenBoost(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasGreenBoost(self)


    def getGreenBoost(self):
        """getGreenBoost(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getGreenBoost(self)


    def setGreenBoost(self, level):
        """setGreenBoost(eVideoManager self, int level)"""
        return _enigma.eVideoManager_setGreenBoost(self, level)


    def hasBlueBoost(self):
        """hasBlueBoost(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasBlueBoost(self)


    def getBlueBoost(self):
        """getBlueBoost(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getBlueBoost(self)


    def setBlueBoost(self, level):
        """setBlueBoost(eVideoManager self, int level)"""
        return _enigma.eVideoManager_setBlueBoost(self, level)


    def hasDynamicContrast(self):
        """hasDynamicContrast(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasDynamicContrast(self)


    def getDynamicContrast(self):
        """getDynamicContrast(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getDynamicContrast(self)


    def setDynamicContrast(self, contrast):
        """setDynamicContrast(eVideoManager self, int contrast)"""
        return _enigma.eVideoManager_setDynamicContrast(self, contrast)


    def hasBlockNoiseReduction(self):
        """hasBlockNoiseReduction(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasBlockNoiseReduction(self)


    def getBlockNoiseReduction(self):
        """getBlockNoiseReduction(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getBlockNoiseReduction(self)


    def setBlockNoiseReduction(self, level):
        """setBlockNoiseReduction(eVideoManager self, int level)"""
        return _enigma.eVideoManager_setBlockNoiseReduction(self, level)


    def hasMosquitoNoiseReduction(self):
        """hasMosquitoNoiseReduction(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasMosquitoNoiseReduction(self)


    def getMosquitoNoiseReduction(self):
        """getMosquitoNoiseReduction(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getMosquitoNoiseReduction(self)


    def setMosquitoNoiseReduction(self, level):
        """setMosquitoNoiseReduction(eVideoManager self, int level)"""
        return _enigma.eVideoManager_setMosquitoNoiseReduction(self, level)


    def hasDigitalContourRemoval(self):
        """hasDigitalContourRemoval(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasDigitalContourRemoval(self)


    def getDigitalContourRemoval(self):
        """getDigitalContourRemoval(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getDigitalContourRemoval(self)


    def setDigitalContourRemoval(self, level):
        """setDigitalContourRemoval(eVideoManager self, int level)"""
        return _enigma.eVideoManager_setDigitalContourRemoval(self, level)


    def hasApplyChanges(self):
        """hasApplyChanges(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasApplyChanges(self)


    def applyChanges(self):
        """applyChanges(eVideoManager self)"""
        return _enigma.eVideoManager_applyChanges(self)


    def hasDeinterlaceMode(self):
        """hasDeinterlaceMode(eVideoManager self) -> bool"""
        return _enigma.eVideoManager_hasDeinterlaceMode(self)


    def getDeinterlaceMode(self):
        """getDeinterlaceMode(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getDeinterlaceMode(self)


    def setDeinterlaceMode(self, mode):
        """setDeinterlaceMode(eVideoManager self, int mode)"""
        return _enigma.eVideoManager_setDeinterlaceMode(self, mode)


    def getContrastRange(self):
        """getContrastRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getContrastRange(self)


    def getSaturationRange(self):
        """getSaturationRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getSaturationRange(self)


    def getHueRange(self):
        """getHueRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getHueRange(self)


    def getBrightnessRange(self):
        """getBrightnessRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getBrightnessRange(self)


    def getColorTempRange(self):
        """getColorTempRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getColorTempRange(self)


    def getScalerSharpnessRange(self):
        """getScalerSharpnessRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getScalerSharpnessRange(self)


    def getSplitModeDefault(self):
        """getSplitModeDefault(eVideoManager self) -> int"""
        return _enigma.eVideoManager_getSplitModeDefault(self)


    def getSharpnessRange(self):
        """getSharpnessRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getSharpnessRange(self)


    def getAutoFleshRange(self):
        """getAutoFleshRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getAutoFleshRange(self)


    def getGreenBoostRange(self):
        """getGreenBoostRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getGreenBoostRange(self)


    def getBlueBoostRange(self):
        """getBlueBoostRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getBlueBoostRange(self)


    def getDynamicContrastRange(self):
        """getDynamicContrastRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getDynamicContrastRange(self)


    def getBlockNoiseReductionRange(self):
        """getBlockNoiseReductionRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getBlockNoiseReductionRange(self)


    def getMosquitoNoiseReductionRange(self):
        """getMosquitoNoiseReductionRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getMosquitoNoiseReductionRange(self)


    def getDigitalContourRemovalRange(self):
        """getDigitalContourRemovalRange(eVideoManager self) -> ePropertyRange"""
        return _enigma.eVideoManager_getDigitalContourRemovalRange(self)

eVideoManager.load = new_instancemethod(_enigma.eVideoManager_load, None, eVideoManager)
eVideoManager.getAvailableSplitModes = new_instancemethod(_enigma.eVideoManager_getAvailableSplitModes, None, eVideoManager)
eVideoManager.getAvailableDeinterlaceModes = new_instancemethod(_enigma.eVideoManager_getAvailableDeinterlaceModes, None, eVideoManager)
eVideoManager.hasContrast = new_instancemethod(_enigma.eVideoManager_hasContrast, None, eVideoManager)
eVideoManager.getContrast = new_instancemethod(_enigma.eVideoManager_getContrast, None, eVideoManager)
eVideoManager.setContrast = new_instancemethod(_enigma.eVideoManager_setContrast, None, eVideoManager)
eVideoManager.hasSaturation = new_instancemethod(_enigma.eVideoManager_hasSaturation, None, eVideoManager)
eVideoManager.getSaturation = new_instancemethod(_enigma.eVideoManager_getSaturation, None, eVideoManager)
eVideoManager.setSaturation = new_instancemethod(_enigma.eVideoManager_setSaturation, None, eVideoManager)
eVideoManager.hasHue = new_instancemethod(_enigma.eVideoManager_hasHue, None, eVideoManager)
eVideoManager.getHue = new_instancemethod(_enigma.eVideoManager_getHue, None, eVideoManager)
eVideoManager.setHue = new_instancemethod(_enigma.eVideoManager_setHue, None, eVideoManager)
eVideoManager.hasBrightness = new_instancemethod(_enigma.eVideoManager_hasBrightness, None, eVideoManager)
eVideoManager.getBrightness = new_instancemethod(_enigma.eVideoManager_getBrightness, None, eVideoManager)
eVideoManager.setBrightness = new_instancemethod(_enigma.eVideoManager_setBrightness, None, eVideoManager)
eVideoManager.hasColorTemp = new_instancemethod(_enigma.eVideoManager_hasColorTemp, None, eVideoManager)
eVideoManager.getColorTemp = new_instancemethod(_enigma.eVideoManager_getColorTemp, None, eVideoManager)
eVideoManager.setColorTemp = new_instancemethod(_enigma.eVideoManager_setColorTemp, None, eVideoManager)
eVideoManager.hasScalerSharpness = new_instancemethod(_enigma.eVideoManager_hasScalerSharpness, None, eVideoManager)
eVideoManager.getScalerSharpness = new_instancemethod(_enigma.eVideoManager_getScalerSharpness, None, eVideoManager)
eVideoManager.setScalerSharpness = new_instancemethod(_enigma.eVideoManager_setScalerSharpness, None, eVideoManager)
eVideoManager.hasSplitMode = new_instancemethod(_enigma.eVideoManager_hasSplitMode, None, eVideoManager)
eVideoManager.getSplitMode = new_instancemethod(_enigma.eVideoManager_getSplitMode, None, eVideoManager)
eVideoManager.setSplitMode = new_instancemethod(_enigma.eVideoManager_setSplitMode, None, eVideoManager)
eVideoManager.hasSharpness = new_instancemethod(_enigma.eVideoManager_hasSharpness, None, eVideoManager)
eVideoManager.getSharpness = new_instancemethod(_enigma.eVideoManager_getSharpness, None, eVideoManager)
eVideoManager.setSharpness = new_instancemethod(_enigma.eVideoManager_setSharpness, None, eVideoManager)
eVideoManager.hasAutoFlesh = new_instancemethod(_enigma.eVideoManager_hasAutoFlesh, None, eVideoManager)
eVideoManager.getAutoFlesh = new_instancemethod(_enigma.eVideoManager_getAutoFlesh, None, eVideoManager)
eVideoManager.setAutoFlesh = new_instancemethod(_enigma.eVideoManager_setAutoFlesh, None, eVideoManager)
eVideoManager.hasGreenBoost = new_instancemethod(_enigma.eVideoManager_hasGreenBoost, None, eVideoManager)
eVideoManager.getGreenBoost = new_instancemethod(_enigma.eVideoManager_getGreenBoost, None, eVideoManager)
eVideoManager.setGreenBoost = new_instancemethod(_enigma.eVideoManager_setGreenBoost, None, eVideoManager)
eVideoManager.hasBlueBoost = new_instancemethod(_enigma.eVideoManager_hasBlueBoost, None, eVideoManager)
eVideoManager.getBlueBoost = new_instancemethod(_enigma.eVideoManager_getBlueBoost, None, eVideoManager)
eVideoManager.setBlueBoost = new_instancemethod(_enigma.eVideoManager_setBlueBoost, None, eVideoManager)
eVideoManager.hasDynamicContrast = new_instancemethod(_enigma.eVideoManager_hasDynamicContrast, None, eVideoManager)
eVideoManager.getDynamicContrast = new_instancemethod(_enigma.eVideoManager_getDynamicContrast, None, eVideoManager)
eVideoManager.setDynamicContrast = new_instancemethod(_enigma.eVideoManager_setDynamicContrast, None, eVideoManager)
eVideoManager.hasBlockNoiseReduction = new_instancemethod(_enigma.eVideoManager_hasBlockNoiseReduction, None, eVideoManager)
eVideoManager.getBlockNoiseReduction = new_instancemethod(_enigma.eVideoManager_getBlockNoiseReduction, None, eVideoManager)
eVideoManager.setBlockNoiseReduction = new_instancemethod(_enigma.eVideoManager_setBlockNoiseReduction, None, eVideoManager)
eVideoManager.hasMosquitoNoiseReduction = new_instancemethod(_enigma.eVideoManager_hasMosquitoNoiseReduction, None, eVideoManager)
eVideoManager.getMosquitoNoiseReduction = new_instancemethod(_enigma.eVideoManager_getMosquitoNoiseReduction, None, eVideoManager)
eVideoManager.setMosquitoNoiseReduction = new_instancemethod(_enigma.eVideoManager_setMosquitoNoiseReduction, None, eVideoManager)
eVideoManager.hasDigitalContourRemoval = new_instancemethod(_enigma.eVideoManager_hasDigitalContourRemoval, None, eVideoManager)
eVideoManager.getDigitalContourRemoval = new_instancemethod(_enigma.eVideoManager_getDigitalContourRemoval, None, eVideoManager)
eVideoManager.setDigitalContourRemoval = new_instancemethod(_enigma.eVideoManager_setDigitalContourRemoval, None, eVideoManager)
eVideoManager.hasApplyChanges = new_instancemethod(_enigma.eVideoManager_hasApplyChanges, None, eVideoManager)
eVideoManager.applyChanges = new_instancemethod(_enigma.eVideoManager_applyChanges, None, eVideoManager)
eVideoManager.hasDeinterlaceMode = new_instancemethod(_enigma.eVideoManager_hasDeinterlaceMode, None, eVideoManager)
eVideoManager.getDeinterlaceMode = new_instancemethod(_enigma.eVideoManager_getDeinterlaceMode, None, eVideoManager)
eVideoManager.setDeinterlaceMode = new_instancemethod(_enigma.eVideoManager_setDeinterlaceMode, None, eVideoManager)
eVideoManager.getContrastRange = new_instancemethod(_enigma.eVideoManager_getContrastRange, None, eVideoManager)
eVideoManager.getSaturationRange = new_instancemethod(_enigma.eVideoManager_getSaturationRange, None, eVideoManager)
eVideoManager.getHueRange = new_instancemethod(_enigma.eVideoManager_getHueRange, None, eVideoManager)
eVideoManager.getBrightnessRange = new_instancemethod(_enigma.eVideoManager_getBrightnessRange, None, eVideoManager)
eVideoManager.getColorTempRange = new_instancemethod(_enigma.eVideoManager_getColorTempRange, None, eVideoManager)
eVideoManager.getScalerSharpnessRange = new_instancemethod(_enigma.eVideoManager_getScalerSharpnessRange, None, eVideoManager)
eVideoManager.getSplitModeDefault = new_instancemethod(_enigma.eVideoManager_getSplitModeDefault, None, eVideoManager)
eVideoManager.getSharpnessRange = new_instancemethod(_enigma.eVideoManager_getSharpnessRange, None, eVideoManager)
eVideoManager.getAutoFleshRange = new_instancemethod(_enigma.eVideoManager_getAutoFleshRange, None, eVideoManager)
eVideoManager.getGreenBoostRange = new_instancemethod(_enigma.eVideoManager_getGreenBoostRange, None, eVideoManager)
eVideoManager.getBlueBoostRange = new_instancemethod(_enigma.eVideoManager_getBlueBoostRange, None, eVideoManager)
eVideoManager.getDynamicContrastRange = new_instancemethod(_enigma.eVideoManager_getDynamicContrastRange, None, eVideoManager)
eVideoManager.getBlockNoiseReductionRange = new_instancemethod(_enigma.eVideoManager_getBlockNoiseReductionRange, None, eVideoManager)
eVideoManager.getMosquitoNoiseReductionRange = new_instancemethod(_enigma.eVideoManager_getMosquitoNoiseReductionRange, None, eVideoManager)
eVideoManager.getDigitalContourRemovalRange = new_instancemethod(_enigma.eVideoManager_getDigitalContourRemovalRange, None, eVideoManager)
eVideoManager_swigregister = _enigma.eVideoManager_swigregister
eVideoManager_swigregister(eVideoManager)

def eVideoManager_getInstance():
    """eVideoManager_getInstance() -> eVideoManager"""
    return _enigma.eVideoManager_getInstance()

class eAudioManager(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() -> eAudioManager"""
        return _enigma.eAudioManager_getInstance()

    getInstance = staticmethod(getInstance)
    FMT_UNDEFINED = _enigma.eAudioManager_FMT_UNDEFINED
    FMT_PCM_STEREO = _enigma.eAudioManager_FMT_PCM_STEREO
    FMT_PCM_MULTICHANNEL = _enigma.eAudioManager_FMT_PCM_MULTICHANNEL
    FMT_AAC = _enigma.eAudioManager_FMT_AAC
    FMT_AC3 = _enigma.eAudioManager_FMT_AC3
    FMT_AC3_PLUS = _enigma.eAudioManager_FMT_AC3_PLUS
    FMT_DTS = _enigma.eAudioManager_FMT_DTS
    FMT_DTS_HD = _enigma.eAudioManager_FMT_DTS_HD
    FMT_DOLBY_DIGITAL_PLUS = _enigma.eAudioManager_FMT_DOLBY_DIGITAL_PLUS
    FMT_DOLBY_TRUE_HD = _enigma.eAudioManager_FMT_DOLBY_TRUE_HD
    FMT_ONE_BIT_AUDIO = _enigma.eAudioManager_FMT_ONE_BIT_AUDIO
    FMT_WMA_PRO = _enigma.eAudioManager_FMT_WMA_PRO
    OUTPUT_HDMI = _enigma.eAudioManager_OUTPUT_HDMI
    OUTPUT_SPDIF = _enigma.eAudioManager_OUTPUT_SPDIF
    OUTPUT_BT = _enigma.eAudioManager_OUTPUT_BT
    MODE_INVALID = _enigma.eAudioManager_MODE_INVALID
    MODE_DOWNMIX = _enigma.eAudioManager_MODE_DOWNMIX
    MODE_PASSTHROUGH = _enigma.eAudioManager_MODE_PASSTHROUGH
    MODE_MULTICHANNEL = _enigma.eAudioManager_MODE_MULTICHANNEL
    MODE_AUTO = _enigma.eAudioManager_MODE_AUTO
    MODE_BEST = _enigma.eAudioManager_MODE_BEST
    MODE_FORCE_DDP = _enigma.eAudioManager_MODE_FORCE_DDP
    MODE_FORCE_AC3 = _enigma.eAudioManager_MODE_FORCE_AC3

    def load(self):
        """load(eAudioManager self)"""
        return _enigma.eAudioManager_load(self)


    def lastReread(self):
        """lastReread(eAudioManager self) -> timespec"""
        return _enigma.eAudioManager_lastReread(self)


    def hasFormat(self, fmt):
        """hasFormat(eAudioManager self, int fmt) -> bool"""
        return _enigma.eAudioManager_hasFormat(self, fmt)


    def hasMode(self, *args):
        """
        hasMode(eAudioManager self, int output, int mode, int fmt) -> bool
        hasMode(eAudioManager self, int output, int mode) -> bool
        """
        return _enigma.eAudioManager_hasMode(self, *args)


    def getAvailableFormats(self):
        """getAvailableFormats(eAudioManager self) -> IntVector"""
        return _enigma.eAudioManager_getAvailableFormats(self)


    def getAvailableModes(self, *args):
        """
        getAvailableModes(eAudioManager self, int output, int fmt) -> IntVector
        getAvailableModes(eAudioManager self, int output) -> IntVector
        """
        return _enigma.eAudioManager_getAvailableModes(self, *args)


    def getMode(self, *args):
        """
        getMode(eAudioManager self, int output, int fmt) -> int
        getMode(eAudioManager self, int output) -> int
        """
        return _enigma.eAudioManager_getMode(self, *args)


    def setMode(self, *args):
        """
        setMode(eAudioManager self, int output, int mode, int fmt) -> bool
        setMode(eAudioManager self, int output, int mode) -> bool
        """
        return _enigma.eAudioManager_setMode(self, *args)


    def getDefaultMode(self, *args):
        """
        getDefaultMode(eAudioManager self, int output, int fmt) -> int
        getDefaultMode(eAudioManager self, int output) -> int
        """
        return _enigma.eAudioManager_getDefaultMode(self, *args)


    def getGeneralDelayRange(self, output, fmt):
        """getGeneralDelayRange(eAudioManager self, int output, int fmt) -> ePropertyRange"""
        return _enigma.eAudioManager_getGeneralDelayRange(self, output, fmt)

    modeChanged = _swig_property(_enigma.eAudioManager_modeChanged_get, _enigma.eAudioManager_modeChanged_set)
eAudioManager.load = new_instancemethod(_enigma.eAudioManager_load, None, eAudioManager)
eAudioManager.lastReread = new_instancemethod(_enigma.eAudioManager_lastReread, None, eAudioManager)
eAudioManager.hasFormat = new_instancemethod(_enigma.eAudioManager_hasFormat, None, eAudioManager)
eAudioManager.hasMode = new_instancemethod(_enigma.eAudioManager_hasMode, None, eAudioManager)
eAudioManager.getAvailableFormats = new_instancemethod(_enigma.eAudioManager_getAvailableFormats, None, eAudioManager)
eAudioManager.getAvailableModes = new_instancemethod(_enigma.eAudioManager_getAvailableModes, None, eAudioManager)
eAudioManager.getMode = new_instancemethod(_enigma.eAudioManager_getMode, None, eAudioManager)
eAudioManager.setMode = new_instancemethod(_enigma.eAudioManager_setMode, None, eAudioManager)
eAudioManager.getDefaultMode = new_instancemethod(_enigma.eAudioManager_getDefaultMode, None, eAudioManager)
eAudioManager.getGeneralDelayRange = new_instancemethod(_enigma.eAudioManager_getGeneralDelayRange, None, eAudioManager)
eAudioManager_swigregister = _enigma.eAudioManager_swigregister
eAudioManager_swigregister(eAudioManager)

def eAudioManager_getInstance():
    """eAudioManager_getInstance() -> eAudioManager"""
    return _enigma.eAudioManager_getInstance()

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


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

    def lock(self, close_device=False):
        """
        lock(eLCD self, bool close_device=False) -> int
        lock(eLCD self) -> int
        """
        return _enigma.eLCD_lock(self, close_device)


    def unlock(self):
        """unlock(eLCD self)"""
        return _enigma.eLCD_unlock(self)


    def islocked(self):
        """islocked(eLCD self) -> int"""
        return _enigma.eLCD_islocked(self)


    def detected(self):
        """detected(eLCD self) -> bool"""
        return _enigma.eLCD_detected(self)

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

    def getInstance():
        """getInstance() -> eDBoxLCD"""
        return _enigma.eDBoxLCD_getInstance()

    getInstance = staticmethod(getInstance)

    def setLCDBrightness(self, brightness):
        """setLCDBrightness(eDBoxLCD self, int brightness) -> int"""
        return _enigma.eDBoxLCD_setLCDBrightness(self, brightness)


    def setInverted(self, arg2):
        """setInverted(eDBoxLCD self, bool arg2)"""
        return _enigma.eDBoxLCD_setInverted(self, arg2)


    def isOled(self):
        """isOled(eDBoxLCD self) -> bool"""
        return _enigma.eDBoxLCD_isOled(self)


    def update(self):
        """update(eDBoxLCD self)"""
        return _enigma.eDBoxLCD_update(self)

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():
    """eDBoxLCD_getInstance() -> eDBoxLCD"""
    return _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

    def getState(self, slot):
        """getState(eMMI_UI self, int slot) -> int"""
        return _enigma.eMMI_UI_getState(self, slot)


    def setState(self, slot, state):
        """setState(eMMI_UI self, int slot, int state)"""
        return _enigma.eMMI_UI_setState(self, slot, state)


    def getAppName(self, slot):
        """getAppName(eMMI_UI self, int slot) -> std::string"""
        return _enigma.eMMI_UI_getAppName(self, slot)


    def setAppName(self, slot, name):
        """setAppName(eMMI_UI self, int slot, char const * name)"""
        return _enigma.eMMI_UI_setAppName(self, slot, name)


    def availableMMI(self, slot):
        """availableMMI(eMMI_UI self, int slot) -> int"""
        return _enigma.eMMI_UI_availableMMI(self, slot)


    def getMMIScreen(self, slot):
        """getMMIScreen(eMMI_UI self, int slot) -> std::list< boost::any,std::allocator< boost::any > > &"""
        return _enigma.eMMI_UI_getMMIScreen(self, slot)

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)

    def getInstance():
        """getInstance() -> eDVBCI_UI"""
        return _enigma.eDVBCI_UI_getInstance()

    getInstance = staticmethod(getInstance)

    def setInit(self, slot):
        """setInit(eDVBCI_UI self, int slot)"""
        return _enigma.eDVBCI_UI_setInit(self, slot)


    def setReset(self, slot):
        """setReset(eDVBCI_UI self, int slot)"""
        return _enigma.eDVBCI_UI_setReset(self, slot)


    def startMMI(self, slot):
        """startMMI(eDVBCI_UI self, int slot) -> int"""
        return _enigma.eDVBCI_UI_startMMI(self, slot)


    def stopMMI(self, slot):
        """stopMMI(eDVBCI_UI self, int slot) -> int"""
        return _enigma.eDVBCI_UI_stopMMI(self, slot)


    def getMMIState(self, slot):
        """getMMIState(eDVBCI_UI self, int slot) -> int"""
        return _enigma.eDVBCI_UI_getMMIState(self, slot)


    def answerMenu(self, slot, answer):
        """answerMenu(eDVBCI_UI self, int slot, int answer) -> int"""
        return _enigma.eDVBCI_UI_answerMenu(self, slot, answer)


    def answerEnq(self, slot, val):
        """answerEnq(eDVBCI_UI self, int slot, char * val) -> int"""
        return _enigma.eDVBCI_UI_answerEnq(self, slot, val)


    def cancelEnq(self, slot):
        """cancelEnq(eDVBCI_UI self, int slot) -> int"""
        return _enigma.eDVBCI_UI_cancelEnq(self, slot)


    def setClockRate(self, slot, rate):
        """setClockRate(eDVBCI_UI self, int slot, int rate) -> int"""
        return _enigma.eDVBCI_UI_setClockRate(self, slot, rate)

    __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():
    """eDVBCI_UI_getInstance() -> eDVBCI_UI"""
    return _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.searchReference = new_instancemethod(_enigma.eDVBDB_searchReference, 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):
        """__init__(ePicLoad self) -> ePicLoad"""
        _enigma.ePicLoad_swiginit(self, _enigma.new_ePicLoad())
    __swig_destroy__ = _enigma.delete_ePicLoad

    def startDecode(self, filename, async=True):
        """
        startDecode(ePicLoad self, char const * filename, bool async=True) -> RESULT
        startDecode(ePicLoad self, char const * filename) -> RESULT
        """
        return _enigma.ePicLoad_startDecode(self, filename, async)


    def startDecodeBuffer(self, picbuf, n, async=True):
        """
        startDecodeBuffer(ePicLoad self, unsigned char const * picbuf, size_t n, bool async=True) -> RESULT
        startDecodeBuffer(ePicLoad self, unsigned char const * picbuf, size_t n) -> RESULT
        """
        return _enigma.ePicLoad_startDecodeBuffer(self, picbuf, n, async)


    def getThumbnail(self, filename):
        """getThumbnail(ePicLoad self, char const * filename) -> RESULT"""
        return _enigma.ePicLoad_getThumbnail(self, filename)


    def setPara(self, arg2):
        """setPara(std::tuple(int maxX, int maxY, int aspectX, int aspectY, int useCache, int scaleMode, std::string backgroundColor) -> RESULT"""
        return _enigma.ePicLoad_setPara(self, arg2)


    def setParameters(self, *args):
        """
        setParameters(ePicLoad self, eSize size, eSize aspectRatio, bool useCache=False, int scaleMode, uint32_t backgroundColor=0xFF000000) -> RESULT
        setParameters(ePicLoad self, eSize size, eSize aspectRatio, bool useCache=False, int scaleMode) -> RESULT
        setParameters(ePicLoad self, eSize size, eSize aspectRatio, bool useCache=False) -> RESULT
        setParameters(ePicLoad self, eSize size, eSize aspectRatio) -> RESULT
        setParameters(ePicLoad self, eSize size) -> RESULT
        """
        return _enigma.ePicLoad_setParameters(self, *args)


    def getInfo(self, filename):
        """getInfo(ePicLoad self, char const * filename) -> StringList"""
        return _enigma.ePicLoad_getInfo(self, filename)


    def getData(self):
        """getData(ePicLoad self)"""
        return _enigma.ePicLoad_getData(self)

ePicLoad.startDecode = new_instancemethod(_enigma.ePicLoad_startDecode, None, ePicLoad)
ePicLoad.startDecodeBuffer = new_instancemethod(_enigma.ePicLoad_startDecodeBuffer, None, ePicLoad)
ePicLoad.getThumbnail = new_instancemethod(_enigma.ePicLoad_getThumbnail, None, ePicLoad)
ePicLoad.setPara = new_instancemethod(_enigma.ePicLoad_setPara, None, ePicLoad)
ePicLoad.setParameters = new_instancemethod(_enigma.ePicLoad_setParameters, 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):
    """
    loadPic(std::string const & filename, int x, int y, int aspect, int resize_mode=0, int rotate=0, int background=0, std::string const & cachefile)
    loadPic(std::string const & filename, int x, int y, int aspect, int resize_mode=0, int rotate=0, int background=0)
    loadPic(std::string const & filename, int x, int y, int aspect, int resize_mode=0, int rotate=0)
    loadPic(std::string const & filename, int x, int y, int aspect, int resize_mode=0)
    loadPic(std::string const & filename, int x, int y, int aspect)
    """
    return _enigma.loadPic(*args)
class cecAddr(object):
    """Proxy of C++ cecAddr class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    phys = _swig_property(_enigma.cecAddr_phys_get, _enigma.cecAddr_phys_set)
    log = _swig_property(_enigma.cecAddr_log_get, _enigma.cecAddr_log_set)

    def __init__(self):
        """__init__(cecAddr self) -> cecAddr"""
        _enigma.cecAddr_swiginit(self, _enigma.new_cecAddr())
    __swig_destroy__ = _enigma.delete_cecAddr
cecAddr_swigregister = _enigma.cecAddr_swigregister
cecAddr_swigregister(cecAddr)

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

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dest = _swig_property(_enigma.cecMessage_dest_get, _enigma.cecMessage_dest_set)
    data = _swig_property(_enigma.cecMessage_data_get, _enigma.cecMessage_data_set)
    len = _swig_property(_enigma.cecMessage_len_get, _enigma.cecMessage_len_set)

    def __init__(self):
        """__init__(cecMessage self) -> cecMessage"""
        _enigma.cecMessage_swiginit(self, _enigma.new_cecMessage())
    __swig_destroy__ = _enigma.delete_cecMessage
cecMessage_swigregister = _enigma.cecMessage_swigregister
cecMessage_swigregister(cecMessage)

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

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    MSG_FEATURE_ABORT = _enigma.eCec_MSG_FEATURE_ABORT
    MSG_IMAGE_VIEW_ON = _enigma.eCec_MSG_IMAGE_VIEW_ON
    MSG_TEXT_VIEW_ON = _enigma.eCec_MSG_TEXT_VIEW_ON
    MSG_SET_MENU_LANG = _enigma.eCec_MSG_SET_MENU_LANG
    MSG_STANDBY = _enigma.eCec_MSG_STANDBY
    MSG_USER_CONTROL_PRESSED = _enigma.eCec_MSG_USER_CONTROL_PRESSED
    MSG_USER_CONTROL_RELEASED = _enigma.eCec_MSG_USER_CONTROL_RELEASED
    MSG_GIVE_OSD_NAME = _enigma.eCec_MSG_GIVE_OSD_NAME
    MSG_SET_OSD_NAME = _enigma.eCec_MSG_SET_OSD_NAME
    MSG_SET_OSD_STRING = _enigma.eCec_MSG_SET_OSD_STRING
    MSG_SYSTEM_AUDIO_MODE_REQUEST = _enigma.eCec_MSG_SYSTEM_AUDIO_MODE_REQUEST
    MSG_GIVE_AUDIO_STATUS = _enigma.eCec_MSG_GIVE_AUDIO_STATUS
    MSG_SET_SYSTEM_AUDIO_MODE = _enigma.eCec_MSG_SET_SYSTEM_AUDIO_MODE
    MSG_REPORT_AUDIO_STATUS = _enigma.eCec_MSG_REPORT_AUDIO_STATUS
    MSG_GIVE_SYSTEM_AUDIO_MODE_STATUS = _enigma.eCec_MSG_GIVE_SYSTEM_AUDIO_MODE_STATUS
    MSG_SYSTEM_AUDIO_MODE_STATUS = _enigma.eCec_MSG_SYSTEM_AUDIO_MODE_STATUS
    MSG_ROUTING_CHANGE = _enigma.eCec_MSG_ROUTING_CHANGE
    MSG_ROUTING_INFORMATION = _enigma.eCec_MSG_ROUTING_INFORMATION
    MSG_ACTIVE_SOURCE = _enigma.eCec_MSG_ACTIVE_SOURCE
    MSG_GIVE_PHYS_ADDR = _enigma.eCec_MSG_GIVE_PHYS_ADDR
    MSG_REPORT_PHYS_ADDR = _enigma.eCec_MSG_REPORT_PHYS_ADDR
    MSG_REQUEST_ACTIVE_SOURCE = _enigma.eCec_MSG_REQUEST_ACTIVE_SOURCE
    MSG_SET_STREAMPATH = _enigma.eCec_MSG_SET_STREAMPATH
    MSG_DEVICE_VENDOR_ID = _enigma.eCec_MSG_DEVICE_VENDOR_ID
    MSG_VENDOR_COMMAND = _enigma.eCec_MSG_VENDOR_COMMAND
    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_GIVE_DEVICE_VENDOR_ID = _enigma.eCec_MSG_GIVE_DEVICE_VENDOR_ID
    MSG_MENU_REQUEST = _enigma.eCec_MSG_MENU_REQUEST
    MSG_MENU_STATUS = _enigma.eCec_MSG_MENU_STATUS
    MSG_GIVE_DEVICE_POWER_STATUS = _enigma.eCec_MSG_GIVE_DEVICE_POWER_STATUS
    MSG_REPORT_POWER_STATUS = _enigma.eCec_MSG_REPORT_POWER_STATUS
    MSG_GET_MENU_LANG = _enigma.eCec_MSG_GET_MENU_LANG
    MSG_SET_AUDIO_RATE = _enigma.eCec_MSG_SET_AUDIO_RATE
    MSG_INACTIVE_SOURCE = _enigma.eCec_MSG_INACTIVE_SOURCE
    MSG_VERSION = _enigma.eCec_MSG_VERSION
    MSG_GET_CEC_VERSION = _enigma.eCec_MSG_GET_CEC_VERSION
    MSG_VENDOR_COMMAND_WITH_ID = _enigma.eCec_MSG_VENDOR_COMMAND_WITH_ID
    MSG_GIVE_DECK_STATUS = _enigma.eCec_MSG_GIVE_DECK_STATUS
    MSG_DECK_STATUS = _enigma.eCec_MSG_DECK_STATUS
    MSG_DECK_CONTROL = _enigma.eCec_MSG_DECK_CONTROL
    ABORT_REASON_UNRECOGNIZED_OPCODE = _enigma.eCec_ABORT_REASON_UNRECOGNIZED_OPCODE
    ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND = _enigma.eCec_ABORT_REASON_NOT_IN_CORRECT_MODE_TO_RESPOND
    ABORT_REASON_CANNOT_PROVIDE_SOURCE = _enigma.eCec_ABORT_REASON_CANNOT_PROVIDE_SOURCE
    ABORT_REASON_INVALID_OPERAND = _enigma.eCec_ABORT_REASON_INVALID_OPERAND
    ABORT_REASON_REFUSED = _enigma.eCec_ABORT_REASON_REFUSED
    ADDR_TV = _enigma.eCec_ADDR_TV
    ADDR_RECORDING_DEVICE_1 = _enigma.eCec_ADDR_RECORDING_DEVICE_1
    ADDR_RECORDING_DEVICE_2 = _enigma.eCec_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_3 = _enigma.eCec_ADDR_RECORDING_DEVICE_3
    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_AMAZON = _enigma.eCec_VENDOR_AMAZON
    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_GOOGLE = _enigma.eCec_VENDOR_GOOGLE
    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_OPPO = _enigma.eCec_VENDOR_OPPO
    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
    RC_SELECT = _enigma.eCec_RC_SELECT
    RC_UP = _enigma.eCec_RC_UP
    RC_DOWN = _enigma.eCec_RC_DOWN
    RC_LEFT = _enigma.eCec_RC_LEFT
    RC_RIGHT = _enigma.eCec_RC_RIGHT
    RC_RIGHT_UP = _enigma.eCec_RC_RIGHT_UP
    RC_RIGHT_DOWN = _enigma.eCec_RC_RIGHT_DOWN
    RC_LEFT_UP = _enigma.eCec_RC_LEFT_UP
    RC_LEFT_DOWN = _enigma.eCec_RC_LEFT_DOWN
    RC_ROOT_MENU = _enigma.eCec_RC_ROOT_MENU
    RC_SETUP_MENU = _enigma.eCec_RC_SETUP_MENU
    RC_CONTENTS_MENU = _enigma.eCec_RC_CONTENTS_MENU
    RC_FAVORITE_MENU = _enigma.eCec_RC_FAVORITE_MENU
    RC_EXIT = _enigma.eCec_RC_EXIT
    RC_0 = _enigma.eCec_RC_0
    RC_1 = _enigma.eCec_RC_1
    RC_2 = _enigma.eCec_RC_2
    RC_3 = _enigma.eCec_RC_3
    RC_4 = _enigma.eCec_RC_4
    RC_5 = _enigma.eCec_RC_5
    RC_6 = _enigma.eCec_RC_6
    RC_7 = _enigma.eCec_RC_7
    RC_8 = _enigma.eCec_RC_8
    RC_9 = _enigma.eCec_RC_9
    RC_CHANNEL_UP = _enigma.eCec_RC_CHANNEL_UP
    RC_CHANNEL_DOWN = _enigma.eCec_RC_CHANNEL_DOWN
    RC_INFO = _enigma.eCec_RC_INFO
    RC_HELP = _enigma.eCec_RC_HELP
    RC_PAGE_UP = _enigma.eCec_RC_PAGE_UP
    RC_PAGE_DOWN = _enigma.eCec_RC_PAGE_DOWN
    RC_POWER = _enigma.eCec_RC_POWER
    RC_VOLUME_UP = _enigma.eCec_RC_VOLUME_UP
    RC_VOLUME_DOWN = _enigma.eCec_RC_VOLUME_DOWN
    RC_MUTE = _enigma.eCec_RC_MUTE
    RC_PLAY = _enigma.eCec_RC_PLAY
    RC_STOP = _enigma.eCec_RC_STOP
    RC_PAUSE = _enigma.eCec_RC_PAUSE
    RC_RECORD = _enigma.eCec_RC_RECORD
    RC_RWD = _enigma.eCec_RC_RWD
    RC_FWD = _enigma.eCec_RC_FWD
    RC_EPG = _enigma.eCec_RC_EPG
    RC_TIMER = _enigma.eCec_RC_TIMER
    RC_PLAY_F = _enigma.eCec_RC_PLAY_F
    RC_PAUSEPLAY_F = _enigma.eCec_RC_PAUSEPLAY_F
    RC_REC_F = _enigma.eCec_RC_REC_F
    RC_STOP_F = _enigma.eCec_RC_STOP_F
    RC_MUTE_F = _enigma.eCec_RC_MUTE_F
    RC_POWER_F = _enigma.eCec_RC_POWER_F
    RC_POWER_OFF = _enigma.eCec_RC_POWER_OFF
    RC_POWER_ON = _enigma.eCec_RC_POWER_ON
    RC_BLUE = _enigma.eCec_RC_BLUE
    RC_RED = _enigma.eCec_RC_RED
    RC_GREEN = _enigma.eCec_RC_GREEN
    RC_YELLOW = _enigma.eCec_RC_YELLOW
    DEVICE_TYPE_TV = _enigma.eCec_DEVICE_TYPE_TV
    DEVICE_TYPE_RECORDING = _enigma.eCec_DEVICE_TYPE_RECORDING
    DEVICE_TYPE_RESERVED = _enigma.eCec_DEVICE_TYPE_RESERVED
    DEVICE_TYPE_TUNER = _enigma.eCec_DEVICE_TYPE_TUNER
    DEVICE_TYPE_PLAYBACK = _enigma.eCec_DEVICE_TYPE_PLAYBACK
    DEVICE_TYPE_AUDIO_SYSTEM = _enigma.eCec_DEVICE_TYPE_AUDIO_SYSTEM
    DEVICE_TYPE_PURE_SWITCH = _enigma.eCec_DEVICE_TYPE_PURE_SWITCH
    DEVICE_TYPE_VIDEO_PROCESSOR = _enigma.eCec_DEVICE_TYPE_VIDEO_PROCESSOR
    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
    DECK_INFO_PLAY = _enigma.eCec_DECK_INFO_PLAY
    DECK_INFO_RECORD = _enigma.eCec_DECK_INFO_RECORD
    DECK_INFO_PLAY_REVERSE = _enigma.eCec_DECK_INFO_PLAY_REVERSE
    DECK_INFO_STILL = _enigma.eCec_DECK_INFO_STILL
    DECK_INFO_SLOW = _enigma.eCec_DECK_INFO_SLOW
    DECK_INFO_SLOW_REVERSE = _enigma.eCec_DECK_INFO_SLOW_REVERSE
    DECK_INFO_FFW = _enigma.eCec_DECK_INFO_FFW
    DECK_INFO_RWD = _enigma.eCec_DECK_INFO_RWD
    DECK_INFO_NO_MEDIA = _enigma.eCec_DECK_INFO_NO_MEDIA
    DECK_INFO_STOP = _enigma.eCec_DECK_INFO_STOP
    DECK_INFO_SKIP_FWD = _enigma.eCec_DECK_INFO_SKIP_FWD
    DECK_INFO_SKIP_RWD = _enigma.eCec_DECK_INFO_SKIP_RWD
    DECK_INFO_INDEX_SEARCH_FWD = _enigma.eCec_DECK_INFO_INDEX_SEARCH_FWD
    DECK_INFO_INDEX_SEARCH_REVERSE = _enigma.eCec_DECK_INFO_INDEX_SEARCH_REVERSE
    DECK_INFO_OTHER_STATE = _enigma.eCec_DECK_INFO_OTHER_STATE

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

    vendor = staticmethod(vendor)

    def checkMessageVendor(vendor, message):
        """checkMessageVendor(uint32_t vendor, uint8_t * message) -> bool"""
        return _enigma.eCec_checkMessageVendor(vendor, message)

    checkMessageVendor = staticmethod(checkMessageVendor)

    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 convert(value, len, data):
        """convert(int value, int len, uint8_t * data)"""
        return _enigma.eCec_convert(value, len, data)

    convert = staticmethod(convert)

    def set_powerstate(self, newstate):
        """set_powerstate(eCec self, uint8_t newstate)"""
        return _enigma.eCec_set_powerstate(self, newstate)


    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, dest):
        """cec_ss_standby(eCec self, int dest)"""
        return _enigma.eCec_cec_ss_standby(self, dest)


    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, dest, code, release=False):
        """
        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, dest, code, release)


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


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


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


    def isReady(self):
        """isReady(eCec self) -> bool"""
        return _enigma.eCec_isReady(self)


    def isActiveSource(self):
        """isActiveSource(eCec self) -> bool"""
        return _enigma.eCec_isActiveSource(self)


    def setName(self, name):
        """setName(eCec self, std::string const & name)"""
        return _enigma.eCec_setName(self, name)


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


    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, dest):
        """systemStandby(eCec self, int dest)"""
        return _enigma.eCec_systemStandby(self, dest)


    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, dest, code, release=False):
        """
        sendKey(eCec self, int dest, int code, bool release=False)
        sendKey(eCec self, int dest, int code)
        """
        return _enigma.eCec_sendKey(self, dest, code, release)


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


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


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


    def getDeviceType(self):
        """getDeviceType(eCec self) -> int"""
        return _enigma.eCec_getDeviceType(self)


    def setDeviceType(self, newType):
        """setDeviceType(eCec self, int newType) -> bool"""
        return _enigma.eCec_setDeviceType(self, newType)


    def getVendor(self):
        """getVendor(eCec self) -> int"""
        return _enigma.eCec_getVendor(self)


    def setVendor(self, vendor):
        """setVendor(eCec self, int vendor)"""
        return _enigma.eCec_setVendor(self, vendor)


    def handleExternal(self, isExternal=True):
        """
        handleExternal(eCec self, bool isExternal=True)
        handleExternal(eCec self)
        """
        return _enigma.eCec_handleExternal(self, isExternal)


    def sendMsg(self, to, cmd, data):
        """sendMsg(eCec self, int to, int cmd, IntList data) -> bool"""
        return _enigma.eCec_sendMsg(self, to, cmd, data)


    def requireAddress(self):
        """requireAddress(eCec self)"""
        return _enigma.eCec_requireAddress(self)


    def getKnownDevices(self):
        """getKnownDevices(eCec self) -> eCecDevicePtrVector"""
        return _enigma.eCec_getKnownDevices(self)


    def physicalAddress(self):
        """physicalAddress(eCec self) -> IntList"""
        return _enigma.eCec_physicalAddress(self)


    def logicalAddress(self):
        """logicalAddress(eCec self) -> int"""
        return _enigma.eCec_logicalAddress(self)

    ready = _swig_property(_enigma.eCec_ready_get, _enigma.eCec_ready_set)
    receivedStandby = _swig_property(_enigma.eCec_receivedStandby_get, _enigma.eCec_receivedStandby_set)
    isNowActive = _swig_property(_enigma.eCec_isNowActive_get, _enigma.eCec_isNowActive_set)
    onKeyPress = _swig_property(_enigma.eCec_onKeyPress_get, _enigma.eCec_onKeyPress_set)
    onKeyRelease = _swig_property(_enigma.eCec_onKeyRelease_get, _enigma.eCec_onKeyRelease_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.isReady = new_instancemethod(_enigma.eCec_isReady, None, eCec)
eCec.isActiveSource = new_instancemethod(_enigma.eCec_isActiveSource, None, eCec)
eCec.setName = new_instancemethod(_enigma.eCec_setName, 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.getDeviceType = new_instancemethod(_enigma.eCec_getDeviceType, None, eCec)
eCec.setDeviceType = new_instancemethod(_enigma.eCec_setDeviceType, None, eCec)
eCec.getVendor = new_instancemethod(_enigma.eCec_getVendor, None, eCec)
eCec.setVendor = new_instancemethod(_enigma.eCec_setVendor, None, eCec)
eCec.handleExternal = new_instancemethod(_enigma.eCec_handleExternal, None, eCec)
eCec.sendMsg = new_instancemethod(_enigma.eCec_sendMsg, None, eCec)
eCec.requireAddress = new_instancemethod(_enigma.eCec_requireAddress, None, eCec)
eCec.getKnownDevices = new_instancemethod(_enigma.eCec_getKnownDevices, None, eCec)
eCec.physicalAddress = new_instancemethod(_enigma.eCec_physicalAddress, None, eCec)
eCec.logicalAddress = new_instancemethod(_enigma.eCec_logicalAddress, None, eCec)
eCec_swigregister = _enigma.eCec_swigregister
eCec_swigregister(eCec)

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

def eCec_checkMessageVendor(vendor, message):
    """eCec_checkMessageVendor(uint32_t vendor, uint8_t * message) -> bool"""
    return _enigma.eCec_checkMessageVendor(vendor, message)

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

def eCec_convert(value, len, data):
    """eCec_convert(int value, int len, uint8_t * data)"""
    return _enigma.eCec_convert(value, len, data)

class eCecDevice(iObject):
    """Proxy of C++ eCecDevice class."""

    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__(eCecDevice self, uint8_t laddr) -> eCecDevice
        __init__(eCecDevice self) -> eCecDevice
        """
        _enigma.eCecDevice_swiginit(self, _enigma.new_eCecDevice(*args))
    __swig_destroy__ = _enigma.delete_eCecDevice

    def logicalAddress(self):
        """logicalAddress(eCecDevice self) -> uint8_t"""
        return _enigma.eCecDevice_logicalAddress(self)


    def vendor(self):
        """vendor(eCecDevice self) -> uint32_t"""
        return _enigma.eCecDevice_vendor(self)


    def readableVendor(self):
        """readableVendor(eCecDevice self) -> std::string"""
        return _enigma.eCecDevice_readableVendor(self)


    def deviceName(self):
        """deviceName(eCecDevice self) -> std::string"""
        return _enigma.eCecDevice_deviceName(self)

eCecDevice.logicalAddress = new_instancemethod(_enigma.eCecDevice_logicalAddress, None, eCecDevice)
eCecDevice.vendor = new_instancemethod(_enigma.eCecDevice_vendor, None, eCecDevice)
eCecDevice.readableVendor = new_instancemethod(_enigma.eCecDevice_readableVendor, None, eCecDevice)
eCecDevice.deviceName = new_instancemethod(_enigma.eCecDevice_deviceName, None, eCecDevice)
eCecDevice_swigregister = _enigma.eCecDevice_swigregister
eCecDevice_swigregister(eCecDevice)

class eCecDevicePtr(object):
    """Proxy of C++ ePtr<(eCecDevice)> class."""

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

    def __ref__(self):
        """__ref__(eCecDevicePtr self) -> eCecDevice"""
        return _enigma.eCecDevicePtr___ref__(self)


    def __init__(self, *args):
        """
        __init__(ePtr<(eCecDevice)> self) -> eCecDevicePtr
        __init__(ePtr<(eCecDevice)> self, eCecDevice c) -> eCecDevicePtr
        __init__(ePtr<(eCecDevice)> self, eCecDevicePtr c) -> eCecDevicePtr
        """
        _enigma.eCecDevicePtr_swiginit(self, _enigma.new_eCecDevicePtr(*args))
    __swig_destroy__ = _enigma.delete_eCecDevicePtr

    def getPtrString(self):
        """getPtrString(eCecDevicePtr self) -> char *"""
        return _enigma.eCecDevicePtr_getPtrString(self)


    def __deref__(self):
        """__deref__(eCecDevicePtr self) -> eCecDevice"""
        return _enigma.eCecDevicePtr___deref__(self)


    def logicalAddress(self):
        """logicalAddress(eCecDevicePtr self) -> uint8_t"""
        return _enigma.eCecDevicePtr_logicalAddress(self)


    def vendor(self):
        """vendor(eCecDevicePtr self) -> uint32_t"""
        return _enigma.eCecDevicePtr_vendor(self)


    def readableVendor(self):
        """readableVendor(eCecDevicePtr self) -> std::string"""
        return _enigma.eCecDevicePtr_readableVendor(self)


    def deviceName(self):
        """deviceName(eCecDevicePtr self) -> std::string"""
        return _enigma.eCecDevicePtr_deviceName(self)

eCecDevicePtr.__ref__ = new_instancemethod(_enigma.eCecDevicePtr___ref__, None, eCecDevicePtr)
eCecDevicePtr.getPtrString = new_instancemethod(_enigma.eCecDevicePtr_getPtrString, None, eCecDevicePtr)
eCecDevicePtr.__deref__ = new_instancemethod(_enigma.eCecDevicePtr___deref__, None, eCecDevicePtr)
eCecDevicePtr.logicalAddress = new_instancemethod(_enigma.eCecDevicePtr_logicalAddress, None, eCecDevicePtr)
eCecDevicePtr.vendor = new_instancemethod(_enigma.eCecDevicePtr_vendor, None, eCecDevicePtr)
eCecDevicePtr.readableVendor = new_instancemethod(_enigma.eCecDevicePtr_readableVendor, None, eCecDevicePtr)
eCecDevicePtr.deviceName = new_instancemethod(_enigma.eCecDevicePtr_deviceName, None, eCecDevicePtr)
eCecDevicePtr_swigregister = _enigma.eCecDevicePtr_swigregister
eCecDevicePtr_swigregister(eCecDevicePtr)

class eCecDevicePtrVector(object):
    """Proxy of C++ std::vector<(ePtr<(eCecDevice)>)> class."""

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

    def iterator(self):
        """iterator(eCecDevicePtrVector self) -> SwigPyIterator"""
        return _enigma.eCecDevicePtrVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(eCecDevicePtrVector self) -> bool"""
        return _enigma.eCecDevicePtrVector___nonzero__(self)


    def __bool__(self):
        """__bool__(eCecDevicePtrVector self) -> bool"""
        return _enigma.eCecDevicePtrVector___bool__(self)


    def __len__(self):
        """__len__(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::size_type"""
        return _enigma.eCecDevicePtrVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, std::vector< ePtr< eCecDevice > >::difference_type j) -> eCecDevicePtrVector"""
        return _enigma.eCecDevicePtrVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, std::vector< ePtr< eCecDevice > >::difference_type j)
        __setslice__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, std::vector< ePtr< eCecDevice > >::difference_type j, eCecDevicePtrVector v)
        """
        return _enigma.eCecDevicePtrVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, std::vector< ePtr< eCecDevice > >::difference_type j)"""
        return _enigma.eCecDevicePtrVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i)
        __delitem__(eCecDevicePtrVector self, PySliceObject * slice)
        """
        return _enigma.eCecDevicePtrVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(eCecDevicePtrVector self, PySliceObject * slice) -> eCecDevicePtrVector
        __getitem__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i) -> eCecDevicePtr
        """
        return _enigma.eCecDevicePtrVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(eCecDevicePtrVector self, PySliceObject * slice, eCecDevicePtrVector v)
        __setitem__(eCecDevicePtrVector self, PySliceObject * slice)
        __setitem__(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::difference_type i, eCecDevicePtr x)
        """
        return _enigma.eCecDevicePtrVector___setitem__(self, *args)


    def pop(self):
        """pop(eCecDevicePtrVector self) -> eCecDevicePtr"""
        return _enigma.eCecDevicePtrVector_pop(self)


    def append(self, x):
        """append(eCecDevicePtrVector self, eCecDevicePtr x)"""
        return _enigma.eCecDevicePtrVector_append(self, x)


    def empty(self):
        """empty(eCecDevicePtrVector self) -> bool"""
        return _enigma.eCecDevicePtrVector_empty(self)


    def size(self):
        """size(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::size_type"""
        return _enigma.eCecDevicePtrVector_size(self)


    def swap(self, v):
        """swap(eCecDevicePtrVector self, eCecDevicePtrVector v)"""
        return _enigma.eCecDevicePtrVector_swap(self, v)


    def begin(self):
        """begin(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::iterator"""
        return _enigma.eCecDevicePtrVector_begin(self)


    def end(self):
        """end(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::iterator"""
        return _enigma.eCecDevicePtrVector_end(self)


    def rbegin(self):
        """rbegin(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::reverse_iterator"""
        return _enigma.eCecDevicePtrVector_rbegin(self)


    def rend(self):
        """rend(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::reverse_iterator"""
        return _enigma.eCecDevicePtrVector_rend(self)


    def clear(self):
        """clear(eCecDevicePtrVector self)"""
        return _enigma.eCecDevicePtrVector_clear(self)


    def get_allocator(self):
        """get_allocator(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::allocator_type"""
        return _enigma.eCecDevicePtrVector_get_allocator(self)


    def pop_back(self):
        """pop_back(eCecDevicePtrVector self)"""
        return _enigma.eCecDevicePtrVector_pop_back(self)


    def erase(self, *args):
        """
        erase(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::iterator pos) -> std::vector< ePtr< eCecDevice > >::iterator
        erase(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::iterator first, std::vector< ePtr< eCecDevice > >::iterator last) -> std::vector< ePtr< eCecDevice > >::iterator
        """
        return _enigma.eCecDevicePtrVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(ePtr<(eCecDevice)>)> self) -> eCecDevicePtrVector
        __init__(std::vector<(ePtr<(eCecDevice)>)> self, eCecDevicePtrVector arg2) -> eCecDevicePtrVector
        __init__(std::vector<(ePtr<(eCecDevice)>)> self, std::vector< ePtr< eCecDevice > >::size_type size) -> eCecDevicePtrVector
        __init__(std::vector<(ePtr<(eCecDevice)>)> self, std::vector< ePtr< eCecDevice > >::size_type size, eCecDevicePtr value) -> eCecDevicePtrVector
        """
        _enigma.eCecDevicePtrVector_swiginit(self, _enigma.new_eCecDevicePtrVector(*args))

    def push_back(self, x):
        """push_back(eCecDevicePtrVector self, eCecDevicePtr x)"""
        return _enigma.eCecDevicePtrVector_push_back(self, x)


    def front(self):
        """front(eCecDevicePtrVector self) -> eCecDevicePtr"""
        return _enigma.eCecDevicePtrVector_front(self)


    def back(self):
        """back(eCecDevicePtrVector self) -> eCecDevicePtr"""
        return _enigma.eCecDevicePtrVector_back(self)


    def assign(self, n, x):
        """assign(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::size_type n, eCecDevicePtr x)"""
        return _enigma.eCecDevicePtrVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::size_type new_size)
        resize(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::size_type new_size, eCecDevicePtr x)
        """
        return _enigma.eCecDevicePtrVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::iterator pos, eCecDevicePtr x) -> std::vector< ePtr< eCecDevice > >::iterator
        insert(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::iterator pos, std::vector< ePtr< eCecDevice > >::size_type n, eCecDevicePtr x)
        """
        return _enigma.eCecDevicePtrVector_insert(self, *args)


    def reserve(self, n):
        """reserve(eCecDevicePtrVector self, std::vector< ePtr< eCecDevice > >::size_type n)"""
        return _enigma.eCecDevicePtrVector_reserve(self, n)


    def capacity(self):
        """capacity(eCecDevicePtrVector self) -> std::vector< ePtr< eCecDevice > >::size_type"""
        return _enigma.eCecDevicePtrVector_capacity(self)

    __swig_destroy__ = _enigma.delete_eCecDevicePtrVector
eCecDevicePtrVector.iterator = new_instancemethod(_enigma.eCecDevicePtrVector_iterator, None, eCecDevicePtrVector)
eCecDevicePtrVector.__nonzero__ = new_instancemethod(_enigma.eCecDevicePtrVector___nonzero__, None, eCecDevicePtrVector)
eCecDevicePtrVector.__bool__ = new_instancemethod(_enigma.eCecDevicePtrVector___bool__, None, eCecDevicePtrVector)
eCecDevicePtrVector.__len__ = new_instancemethod(_enigma.eCecDevicePtrVector___len__, None, eCecDevicePtrVector)
eCecDevicePtrVector.__getslice__ = new_instancemethod(_enigma.eCecDevicePtrVector___getslice__, None, eCecDevicePtrVector)
eCecDevicePtrVector.__setslice__ = new_instancemethod(_enigma.eCecDevicePtrVector___setslice__, None, eCecDevicePtrVector)
eCecDevicePtrVector.__delslice__ = new_instancemethod(_enigma.eCecDevicePtrVector___delslice__, None, eCecDevicePtrVector)
eCecDevicePtrVector.__delitem__ = new_instancemethod(_enigma.eCecDevicePtrVector___delitem__, None, eCecDevicePtrVector)
eCecDevicePtrVector.__getitem__ = new_instancemethod(_enigma.eCecDevicePtrVector___getitem__, None, eCecDevicePtrVector)
eCecDevicePtrVector.__setitem__ = new_instancemethod(_enigma.eCecDevicePtrVector___setitem__, None, eCecDevicePtrVector)
eCecDevicePtrVector.pop = new_instancemethod(_enigma.eCecDevicePtrVector_pop, None, eCecDevicePtrVector)
eCecDevicePtrVector.append = new_instancemethod(_enigma.eCecDevicePtrVector_append, None, eCecDevicePtrVector)
eCecDevicePtrVector.empty = new_instancemethod(_enigma.eCecDevicePtrVector_empty, None, eCecDevicePtrVector)
eCecDevicePtrVector.size = new_instancemethod(_enigma.eCecDevicePtrVector_size, None, eCecDevicePtrVector)
eCecDevicePtrVector.swap = new_instancemethod(_enigma.eCecDevicePtrVector_swap, None, eCecDevicePtrVector)
eCecDevicePtrVector.begin = new_instancemethod(_enigma.eCecDevicePtrVector_begin, None, eCecDevicePtrVector)
eCecDevicePtrVector.end = new_instancemethod(_enigma.eCecDevicePtrVector_end, None, eCecDevicePtrVector)
eCecDevicePtrVector.rbegin = new_instancemethod(_enigma.eCecDevicePtrVector_rbegin, None, eCecDevicePtrVector)
eCecDevicePtrVector.rend = new_instancemethod(_enigma.eCecDevicePtrVector_rend, None, eCecDevicePtrVector)
eCecDevicePtrVector.clear = new_instancemethod(_enigma.eCecDevicePtrVector_clear, None, eCecDevicePtrVector)
eCecDevicePtrVector.get_allocator = new_instancemethod(_enigma.eCecDevicePtrVector_get_allocator, None, eCecDevicePtrVector)
eCecDevicePtrVector.pop_back = new_instancemethod(_enigma.eCecDevicePtrVector_pop_back, None, eCecDevicePtrVector)
eCecDevicePtrVector.erase = new_instancemethod(_enigma.eCecDevicePtrVector_erase, None, eCecDevicePtrVector)
eCecDevicePtrVector.push_back = new_instancemethod(_enigma.eCecDevicePtrVector_push_back, None, eCecDevicePtrVector)
eCecDevicePtrVector.front = new_instancemethod(_enigma.eCecDevicePtrVector_front, None, eCecDevicePtrVector)
eCecDevicePtrVector.back = new_instancemethod(_enigma.eCecDevicePtrVector_back, None, eCecDevicePtrVector)
eCecDevicePtrVector.assign = new_instancemethod(_enigma.eCecDevicePtrVector_assign, None, eCecDevicePtrVector)
eCecDevicePtrVector.resize = new_instancemethod(_enigma.eCecDevicePtrVector_resize, None, eCecDevicePtrVector)
eCecDevicePtrVector.insert = new_instancemethod(_enigma.eCecDevicePtrVector_insert, None, eCecDevicePtrVector)
eCecDevicePtrVector.reserve = new_instancemethod(_enigma.eCecDevicePtrVector_reserve, None, eCecDevicePtrVector)
eCecDevicePtrVector.capacity = new_instancemethod(_enigma.eCecDevicePtrVector_capacity, None, eCecDevicePtrVector)
eCecDevicePtrVector_swigregister = _enigma.eCecDevicePtrVector_swigregister
eCecDevicePtrVector_swigregister(eCecDevicePtrVector)

HBBTV_USER_AGENT = _enigma.HBBTV_USER_AGENT
class eHbbtv(object):
    """Proxy of C++ eHbbtv class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    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
    STREAM_ERROR_NO_RESOURCES = _enigma.eHbbtv_STREAM_ERROR_NO_RESOURCES
    STREAM_ERROR_CORRUPT = _enigma.eHbbtv_STREAM_ERROR_CORRUPT
    STREAM_ERROR_UNAVAILABLE = _enigma.eHbbtv_STREAM_ERROR_UNAVAILABLE
    STREAM_ERROR_UNAVAILABLE_POS = _enigma.eHbbtv_STREAM_ERROR_UNAVAILABLE_POS

    def getInstance():
        """getInstance() -> eHbbtv"""
        return _enigma.eHbbtv_getInstance()

    getInstance = staticmethod(getInstance)

    def setAitSignalsEnabled(self, enabled):
        """setAitSignalsEnabled(eHbbtv self, bool enabled)"""
        return _enigma.eHbbtv_setAitSignalsEnabled(self, enabled)


    def setServiceList(self, sref):
        """setServiceList(eHbbtv self, std::string sref)"""
        return _enigma.eHbbtv_setServiceList(self, sref)


    def setStreamState(self, *args):
        """
        setStreamState(eHbbtv self, int state, int error)
        setStreamState(eHbbtv self, int state)
        """
        return _enigma.eHbbtv_setStreamState(self, *args)


    def getApplication(self, id):
        """getApplication(eHbbtv self, std::string const & id) -> eOipfApplication"""
        return _enigma.eHbbtv_getApplication(self, id)


    def resolveApplicationLocator(self, dvbUrl):
        """resolveApplicationLocator(eHbbtv self, std::string const & dvbUrl) -> std::string const"""
        return _enigma.eHbbtv_resolveApplicationLocator(self, dvbUrl)


    def getApplicationIdsAndName(self):
        """getApplicationIdsAndName(eHbbtv self) -> std::list< std::pair< std::string,std::string >,std::allocator< std::pair< std::string,std::string > > >"""
        return _enigma.eHbbtv_getApplicationIdsAndName(self)


    def pageLoadFinished(self):
        """pageLoadFinished(eHbbtv self)"""
        return _enigma.eHbbtv_pageLoadFinished(self)

    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)
    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():
    """eHbbtv_getInstance() -> eHbbtv"""
    return _enigma.eHbbtv_getInstance()

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

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    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

    def getById(id):
        """getById(std::string const & id) -> eOipfApplication"""
        return _enigma.eOipfApplication_getById(id)

    getById = staticmethod(getById)

    def isValid(self):
        """isValid(eOipfApplication self) -> bool"""
        return _enigma.eOipfApplication_isValid(self)


    def getOrganisationId(self):
        """getOrganisationId(eOipfApplication self) -> uint32_t"""
        return _enigma.eOipfApplication_getOrganisationId(self)


    def getApplicationId(self):
        """getApplicationId(eOipfApplication self) -> uint16_t"""
        return _enigma.eOipfApplication_getApplicationId(self)


    def getApplicationProfile(self):
        """getApplicationProfile(eOipfApplication self) -> uint16_t"""
        return _enigma.eOipfApplication_getApplicationProfile(self)


    def getPriority(self):
        """getPriority(eOipfApplication self) -> uint8_t"""
        return _enigma.eOipfApplication_getPriority(self)


    def getUsageType(self):
        """getUsageType(eOipfApplication self) -> uint8_t"""
        return _enigma.eOipfApplication_getUsageType(self)


    def getControlCode(self):
        """getControlCode(eOipfApplication self) -> uint8_t"""
        return _enigma.eOipfApplication_getControlCode(self)


    def getServiceBoundFlag(self):
        """getServiceBoundFlag(eOipfApplication self) -> uint8_t"""
        return _enigma.eOipfApplication_getServiceBoundFlag(self)


    def getVisibility(self):
        """getVisibility(eOipfApplication self) -> uint8_t"""
        return _enigma.eOipfApplication_getVisibility(self)


    def getId(self):
        """getId(eOipfApplication self) -> std::string const &"""
        return _enigma.eOipfApplication_getId(self)


    def getName(self):
        """getName(eOipfApplication self) -> std::string const &"""
        return _enigma.eOipfApplication_getName(self)


    def getInitialPath(self):
        """getInitialPath(eOipfApplication self) -> std::string const &"""
        return _enigma.eOipfApplication_getInitialPath(self)


    def getUrlBase(self):
        """getUrlBase(eOipfApplication self) -> std::string const &"""
        return _enigma.eOipfApplication_getUrlBase(self)

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(id):
    """eOipfApplication_getById(std::string const & id) -> eOipfApplication"""
    return _enigma.eOipfApplication_getById(id)

class PseudoDict(object):
    """Proxy of C++ std::map<(std::string,boost::any)> class."""

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

    def iterator(self):
        """iterator(PseudoDict self) -> SwigPyIterator"""
        return _enigma.PseudoDict_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(PseudoDict self) -> bool"""
        return _enigma.PseudoDict___nonzero__(self)


    def __bool__(self):
        """__bool__(PseudoDict self) -> bool"""
        return _enigma.PseudoDict___bool__(self)


    def __len__(self):
        """__len__(PseudoDict self) -> std::map< std::string,boost::any >::size_type"""
        return _enigma.PseudoDict___len__(self)

    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 __getitem__(self, key):
        """__getitem__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key) -> std::map< std::string,boost::any >::mapped_type const &"""
        return _enigma.PseudoDict___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key)"""
        return _enigma.PseudoDict___delitem__(self, key)


    def has_key(self, key):
        """has_key(PseudoDict self, std::map< std::string,boost::any >::key_type const & key) -> bool"""
        return _enigma.PseudoDict_has_key(self, key)


    def keys(self):
        """keys(PseudoDict self) -> PyObject *"""
        return _enigma.PseudoDict_keys(self)


    def values(self):
        """values(PseudoDict self) -> PyObject *"""
        return _enigma.PseudoDict_values(self)


    def items(self):
        """items(PseudoDict self) -> PyObject *"""
        return _enigma.PseudoDict_items(self)


    def __contains__(self, key):
        """__contains__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key) -> bool"""
        return _enigma.PseudoDict___contains__(self, key)


    def key_iterator(self):
        """key_iterator(PseudoDict self) -> SwigPyIterator"""
        return _enigma.PseudoDict_key_iterator(self)


    def value_iterator(self):
        """value_iterator(PseudoDict self) -> SwigPyIterator"""
        return _enigma.PseudoDict_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key)
        __setitem__(PseudoDict self, std::map< std::string,boost::any >::key_type const & key, std::map< std::string,boost::any >::mapped_type const & x)
        """
        return _enigma.PseudoDict___setitem__(self, *args)


    def asdict(self):
        """asdict(PseudoDict self) -> PyObject *"""
        return _enigma.PseudoDict_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,boost::any)> self, std::less< std::string > const & arg2) -> PseudoDict
        __init__(std::map<(std::string,boost::any)> self) -> PseudoDict
        __init__(std::map<(std::string,boost::any)> self, PseudoDict arg2) -> PseudoDict
        """
        _enigma.PseudoDict_swiginit(self, _enigma.new_PseudoDict(*args))

    def empty(self):
        """empty(PseudoDict self) -> bool"""
        return _enigma.PseudoDict_empty(self)


    def size(self):
        """size(PseudoDict self) -> std::map< std::string,boost::any >::size_type"""
        return _enigma.PseudoDict_size(self)


    def swap(self, v):
        """swap(PseudoDict self, PseudoDict v)"""
        return _enigma.PseudoDict_swap(self, v)


    def begin(self):
        """begin(PseudoDict self) -> std::map< std::string,boost::any >::iterator"""
        return _enigma.PseudoDict_begin(self)


    def end(self):
        """end(PseudoDict self) -> std::map< std::string,boost::any >::iterator"""
        return _enigma.PseudoDict_end(self)


    def rbegin(self):
        """rbegin(PseudoDict self) -> std::map< std::string,boost::any >::reverse_iterator"""
        return _enigma.PseudoDict_rbegin(self)


    def rend(self):
        """rend(PseudoDict self) -> std::map< std::string,boost::any >::reverse_iterator"""
        return _enigma.PseudoDict_rend(self)


    def clear(self):
        """clear(PseudoDict self)"""
        return _enigma.PseudoDict_clear(self)


    def get_allocator(self):
        """get_allocator(PseudoDict self) -> std::map< std::string,boost::any >::allocator_type"""
        return _enigma.PseudoDict_get_allocator(self)


    def count(self, x):
        """count(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::size_type"""
        return _enigma.PseudoDict_count(self, x)


    def erase(self, *args):
        """
        erase(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::size_type
        erase(PseudoDict self, std::map< std::string,boost::any >::iterator position)
        erase(PseudoDict self, std::map< std::string,boost::any >::iterator first, std::map< std::string,boost::any >::iterator last)
        """
        return _enigma.PseudoDict_erase(self, *args)


    def find(self, x):
        """find(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::iterator"""
        return _enigma.PseudoDict_find(self, x)


    def lower_bound(self, x):
        """lower_bound(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::iterator"""
        return _enigma.PseudoDict_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(PseudoDict self, std::map< std::string,boost::any >::key_type const & x) -> std::map< std::string,boost::any >::iterator"""
        return _enigma.PseudoDict_upper_bound(self, x)


    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.swap = new_instancemethod(_enigma.PseudoDict_swap, 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.clear = new_instancemethod(_enigma.PseudoDict_clear, None, PseudoDict)
PseudoDict.get_allocator = new_instancemethod(_enigma.PseudoDict_get_allocator, 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):
    """Proxy of C++ std::list<(std::string)> class."""

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

    def iterator(self):
        """iterator(StringList self) -> SwigPyIterator"""
        return _enigma.StringList_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(StringList self) -> bool"""
        return _enigma.StringList___nonzero__(self)


    def __bool__(self):
        """__bool__(StringList self) -> bool"""
        return _enigma.StringList___bool__(self)


    def __len__(self):
        """__len__(StringList self) -> std::list< std::string >::size_type"""
        return _enigma.StringList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::difference_type j) -> StringList"""
        return _enigma.StringList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::difference_type j)
        __setslice__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::difference_type j, StringList v)
        """
        return _enigma.StringList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::difference_type j)"""
        return _enigma.StringList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(StringList self, std::list< std::string >::difference_type i)
        __delitem__(StringList self, PySliceObject * slice)
        """
        return _enigma.StringList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(StringList self, PySliceObject * slice) -> StringList
        __getitem__(StringList self, std::list< std::string >::difference_type i) -> std::list< std::string >::value_type const &
        """
        return _enigma.StringList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(StringList self, PySliceObject * slice, StringList v)
        __setitem__(StringList self, PySliceObject * slice)
        __setitem__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::value_type const & x)
        """
        return _enigma.StringList___setitem__(self, *args)


    def pop(self):
        """pop(StringList self) -> std::list< std::string >::value_type"""
        return _enigma.StringList_pop(self)


    def append(self, x):
        """append(StringList self, std::list< std::string >::value_type const & x)"""
        return _enigma.StringList_append(self, x)


    def empty(self):
        """empty(StringList self) -> bool"""
        return _enigma.StringList_empty(self)


    def size(self):
        """size(StringList self) -> std::list< std::string >::size_type"""
        return _enigma.StringList_size(self)


    def swap(self, v):
        """swap(StringList self, StringList v)"""
        return _enigma.StringList_swap(self, v)


    def begin(self):
        """begin(StringList self) -> std::list< std::string >::iterator"""
        return _enigma.StringList_begin(self)


    def end(self):
        """end(StringList self) -> std::list< std::string >::iterator"""
        return _enigma.StringList_end(self)


    def rbegin(self):
        """rbegin(StringList self) -> std::list< std::string >::reverse_iterator"""
        return _enigma.StringList_rbegin(self)


    def rend(self):
        """rend(StringList self) -> std::list< std::string >::reverse_iterator"""
        return _enigma.StringList_rend(self)


    def clear(self):
        """clear(StringList self)"""
        return _enigma.StringList_clear(self)


    def get_allocator(self):
        """get_allocator(StringList self) -> std::list< std::string >::allocator_type"""
        return _enigma.StringList_get_allocator(self)


    def pop_back(self):
        """pop_back(StringList self)"""
        return _enigma.StringList_pop_back(self)


    def erase(self, *args):
        """
        erase(StringList self, std::list< std::string >::iterator pos) -> std::list< std::string >::iterator
        erase(StringList self, std::list< std::string >::iterator first, std::list< std::string >::iterator last) -> std::list< std::string >::iterator
        """
        return _enigma.StringList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(std::string)> self) -> StringList
        __init__(std::list<(std::string)> self, StringList arg2) -> StringList
        __init__(std::list<(std::string)> self, std::list< std::string >::size_type size) -> StringList
        __init__(std::list<(std::string)> self, std::list< std::string >::size_type size, std::list< std::string >::value_type const & value) -> StringList
        """
        _enigma.StringList_swiginit(self, _enigma.new_StringList(*args))

    def push_back(self, x):
        """push_back(StringList self, std::list< std::string >::value_type const & x)"""
        return _enigma.StringList_push_back(self, x)


    def front(self):
        """front(StringList self) -> std::list< std::string >::value_type const &"""
        return _enigma.StringList_front(self)


    def back(self):
        """back(StringList self) -> std::list< std::string >::value_type const &"""
        return _enigma.StringList_back(self)


    def assign(self, n, x):
        """assign(StringList self, std::list< std::string >::size_type n, std::list< std::string >::value_type const & x)"""
        return _enigma.StringList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(StringList self, std::list< std::string >::size_type new_size)
        resize(StringList self, std::list< std::string >::size_type new_size, std::list< std::string >::value_type const & x)
        """
        return _enigma.StringList_resize(self, *args)


    def insert(self, *args):
        """
        insert(StringList self, std::list< std::string >::iterator pos, std::list< std::string >::value_type const & x) -> std::list< std::string >::iterator
        insert(StringList self, std::list< std::string >::iterator pos, std::list< std::string >::size_type n, std::list< std::string >::value_type const & x)
        """
        return _enigma.StringList_insert(self, *args)


    def pop_front(self):
        """pop_front(StringList self)"""
        return _enigma.StringList_pop_front(self)


    def push_front(self, x):
        """push_front(StringList self, std::list< std::string >::value_type const & x)"""
        return _enigma.StringList_push_front(self, x)


    def reverse(self):
        """reverse(StringList self)"""
        return _enigma.StringList_reverse(self)

    __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.__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.pop = new_instancemethod(_enigma.StringList_pop, 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.swap = new_instancemethod(_enigma.StringList_swap, 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.clear = new_instancemethod(_enigma.StringList_clear, None, StringList)
StringList.get_allocator = new_instancemethod(_enigma.StringList_get_allocator, 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):
    """Proxy of C++ std::set<(std::string)> class."""

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

    def iterator(self):
        """iterator(StringSet self) -> SwigPyIterator"""
        return _enigma.StringSet_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(StringSet self) -> bool"""
        return _enigma.StringSet___nonzero__(self)


    def __bool__(self):
        """__bool__(StringSet self) -> bool"""
        return _enigma.StringSet___bool__(self)


    def __len__(self):
        """__len__(StringSet self) -> std::set< std::string >::size_type"""
        return _enigma.StringSet___len__(self)


    def append(self, x):
        """append(StringSet self, std::set< std::string >::value_type x)"""
        return _enigma.StringSet_append(self, x)


    def __contains__(self, x):
        """__contains__(StringSet self, std::set< std::string >::value_type x) -> bool"""
        return _enigma.StringSet___contains__(self, x)


    def __getitem__(self, i):
        """__getitem__(StringSet self, std::set< std::string >::difference_type i) -> std::set< std::string >::value_type"""
        return _enigma.StringSet___getitem__(self, i)


    def add(self, x):
        """add(StringSet self, std::set< std::string >::value_type x)"""
        return _enigma.StringSet_add(self, x)


    def discard(self, x):
        """discard(StringSet self, std::set< std::string >::value_type x)"""
        return _enigma.StringSet_discard(self, x)


    def __init__(self, *args):
        """
        __init__(std::set<(std::string)> self, std::less< std::string > const & arg2) -> StringSet
        __init__(std::set<(std::string)> self) -> StringSet
        __init__(std::set<(std::string)> self, StringSet arg2) -> StringSet
        """
        _enigma.StringSet_swiginit(self, _enigma.new_StringSet(*args))

    def empty(self):
        """empty(StringSet self) -> bool"""
        return _enigma.StringSet_empty(self)


    def size(self):
        """size(StringSet self) -> std::set< std::string >::size_type"""
        return _enigma.StringSet_size(self)


    def clear(self):
        """clear(StringSet self)"""
        return _enigma.StringSet_clear(self)


    def swap(self, v):
        """swap(StringSet self, StringSet v)"""
        return _enigma.StringSet_swap(self, v)


    def count(self, x):
        """count(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::size_type"""
        return _enigma.StringSet_count(self, x)


    def begin(self):
        """begin(StringSet self) -> std::set< std::string >::iterator"""
        return _enigma.StringSet_begin(self)


    def end(self):
        """end(StringSet self) -> std::set< std::string >::iterator"""
        return _enigma.StringSet_end(self)


    def rbegin(self):
        """rbegin(StringSet self) -> std::set< std::string >::reverse_iterator"""
        return _enigma.StringSet_rbegin(self)


    def rend(self):
        """rend(StringSet self) -> std::set< std::string >::reverse_iterator"""
        return _enigma.StringSet_rend(self)


    def erase(self, *args):
        """
        erase(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::size_type
        erase(StringSet self, std::set< std::string >::iterator pos)
        erase(StringSet self, std::set< std::string >::iterator first, std::set< std::string >::iterator last)
        """
        return _enigma.StringSet_erase(self, *args)


    def find(self, x):
        """find(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator"""
        return _enigma.StringSet_find(self, x)


    def lower_bound(self, x):
        """lower_bound(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator"""
        return _enigma.StringSet_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator"""
        return _enigma.StringSet_upper_bound(self, x)


    def equal_range(self, x):
        """equal_range(StringSet self, std::set< std::string >::key_type const & x) -> std::pair< std::set< std::string >::iterator,std::set< std::string >::iterator >"""
        return _enigma.StringSet_equal_range(self, x)


    def insert(self, __x):
        """insert(StringSet self, std::set< std::string >::value_type const & __x) -> std::pair< std::set< std::string >::iterator,bool >"""
        return _enigma.StringSet_insert(self, __x)

    __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):
    """Proxy of C++ std::map<(std::string,std::string)> class."""

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

    def iterator(self):
        """iterator(StringMap self) -> SwigPyIterator"""
        return _enigma.StringMap_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(StringMap self) -> bool"""
        return _enigma.StringMap___nonzero__(self)


    def __bool__(self):
        """__bool__(StringMap self) -> bool"""
        return _enigma.StringMap___bool__(self)


    def __len__(self):
        """__len__(StringMap self) -> std::map< std::string,std::string >::size_type"""
        return _enigma.StringMap___len__(self)

    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 __getitem__(self, key):
        """__getitem__(StringMap self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _enigma.StringMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(StringMap self, std::map< std::string,std::string >::key_type const & key)"""
        return _enigma.StringMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(StringMap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _enigma.StringMap_has_key(self, key)


    def keys(self):
        """keys(StringMap self) -> PyObject *"""
        return _enigma.StringMap_keys(self)


    def values(self):
        """values(StringMap self) -> PyObject *"""
        return _enigma.StringMap_values(self)


    def items(self):
        """items(StringMap self) -> PyObject *"""
        return _enigma.StringMap_items(self)


    def __contains__(self, key):
        """__contains__(StringMap self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _enigma.StringMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(StringMap self) -> SwigPyIterator"""
        return _enigma.StringMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(StringMap self) -> SwigPyIterator"""
        return _enigma.StringMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(StringMap self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(StringMap self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _enigma.StringMap___setitem__(self, *args)


    def asdict(self):
        """asdict(StringMap self) -> PyObject *"""
        return _enigma.StringMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,std::string)> self, std::less< std::string > const & arg2) -> StringMap
        __init__(std::map<(std::string,std::string)> self) -> StringMap
        __init__(std::map<(std::string,std::string)> self, StringMap arg2) -> StringMap
        """
        _enigma.StringMap_swiginit(self, _enigma.new_StringMap(*args))

    def empty(self):
        """empty(StringMap self) -> bool"""
        return _enigma.StringMap_empty(self)


    def size(self):
        """size(StringMap self) -> std::map< std::string,std::string >::size_type"""
        return _enigma.StringMap_size(self)


    def swap(self, v):
        """swap(StringMap self, StringMap v)"""
        return _enigma.StringMap_swap(self, v)


    def begin(self):
        """begin(StringMap self) -> std::map< std::string,std::string >::iterator"""
        return _enigma.StringMap_begin(self)


    def end(self):
        """end(StringMap self) -> std::map< std::string,std::string >::iterator"""
        return _enigma.StringMap_end(self)


    def rbegin(self):
        """rbegin(StringMap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _enigma.StringMap_rbegin(self)


    def rend(self):
        """rend(StringMap self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _enigma.StringMap_rend(self)


    def clear(self):
        """clear(StringMap self)"""
        return _enigma.StringMap_clear(self)


    def get_allocator(self):
        """get_allocator(StringMap self) -> std::map< std::string,std::string >::allocator_type"""
        return _enigma.StringMap_get_allocator(self)


    def count(self, x):
        """count(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _enigma.StringMap_count(self, x)


    def erase(self, *args):
        """
        erase(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(StringMap self, std::map< std::string,std::string >::iterator position)
        erase(StringMap self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _enigma.StringMap_erase(self, *args)


    def find(self, x):
        """find(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _enigma.StringMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _enigma.StringMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(StringMap self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _enigma.StringMap_upper_bound(self, x)


    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.swap = new_instancemethod(_enigma.StringMap_swap, 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.clear = new_instancemethod(_enigma.StringMap_clear, None, StringMap)
StringMap.get_allocator = new_instancemethod(_enigma.StringMap_get_allocator, 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):
    """Proxy of C++ std::vector<(std::map<(std::string,std::string)>)> class."""

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

    def iterator(self):
        """iterator(StringMapVector self) -> SwigPyIterator"""
        return _enigma.StringMapVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(StringMapVector self) -> bool"""
        return _enigma.StringMapVector___nonzero__(self)


    def __bool__(self):
        """__bool__(StringMapVector self) -> bool"""
        return _enigma.StringMapVector___bool__(self)


    def __len__(self):
        """__len__(StringMapVector self) -> std::vector< std::map< std::string,std::string > >::size_type"""
        return _enigma.StringMapVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(StringMapVector self, std::vector< std::map< std::string,std::string > >::difference_type i, std::vector< std::map< std::string,std::string > >::difference_type j) -> StringMapVector"""
        return _enigma.StringMapVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(StringMapVector self, std::vector< std::map< std::string,std::string > >::difference_type i, std::vector< std::map< std::string,std::string > >::difference_type j)
        __setslice__(StringMapVector self, std::vector< std::map< std::string,std::string > >::difference_type i, std::vector< std::map< std::string,std::string > >::difference_type j, StringMapVector v)
        """
        return _enigma.StringMapVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(StringMapVector self, std::vector< std::map< std::string,std::string > >::difference_type i, std::vector< std::map< std::string,std::string > >::difference_type j)"""
        return _enigma.StringMapVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(StringMapVector self, std::vector< std::map< std::string,std::string > >::difference_type i)
        __delitem__(StringMapVector self, PySliceObject * slice)
        """
        return _enigma.StringMapVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(StringMapVector self, PySliceObject * slice) -> StringMapVector
        __getitem__(StringMapVector self, std::vector< std::map< std::string,std::string > >::difference_type i) -> StringMap
        """
        return _enigma.StringMapVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(StringMapVector self, PySliceObject * slice, StringMapVector v)
        __setitem__(StringMapVector self, PySliceObject * slice)
        __setitem__(StringMapVector self, std::vector< std::map< std::string,std::string > >::difference_type i, StringMap x)
        """
        return _enigma.StringMapVector___setitem__(self, *args)


    def pop(self):
        """pop(StringMapVector self) -> StringMap"""
        return _enigma.StringMapVector_pop(self)


    def append(self, x):
        """append(StringMapVector self, StringMap x)"""
        return _enigma.StringMapVector_append(self, x)


    def empty(self):
        """empty(StringMapVector self) -> bool"""
        return _enigma.StringMapVector_empty(self)


    def size(self):
        """size(StringMapVector self) -> std::vector< std::map< std::string,std::string > >::size_type"""
        return _enigma.StringMapVector_size(self)


    def swap(self, v):
        """swap(StringMapVector self, StringMapVector v)"""
        return _enigma.StringMapVector_swap(self, v)


    def begin(self):
        """begin(StringMapVector self) -> std::vector< std::map< std::string,std::string > >::iterator"""
        return _enigma.StringMapVector_begin(self)


    def end(self):
        """end(StringMapVector self) -> std::vector< std::map< std::string,std::string > >::iterator"""
        return _enigma.StringMapVector_end(self)


    def rbegin(self):
        """rbegin(StringMapVector self) -> std::vector< std::map< std::string,std::string > >::reverse_iterator"""
        return _enigma.StringMapVector_rbegin(self)


    def rend(self):
        """rend(StringMapVector self) -> std::vector< std::map< std::string,std::string > >::reverse_iterator"""
        return _enigma.StringMapVector_rend(self)


    def clear(self):
        """clear(StringMapVector self)"""
        return _enigma.StringMapVector_clear(self)


    def get_allocator(self):
        """get_allocator(StringMapVector self) -> std::vector< std::map< std::string,std::string > >::allocator_type"""
        return _enigma.StringMapVector_get_allocator(self)


    def pop_back(self):
        """pop_back(StringMapVector self)"""
        return _enigma.StringMapVector_pop_back(self)


    def erase(self, *args):
        """
        erase(StringMapVector self, std::vector< std::map< std::string,std::string > >::iterator pos) -> std::vector< std::map< std::string,std::string > >::iterator
        erase(StringMapVector self, std::vector< std::map< std::string,std::string > >::iterator first, std::vector< std::map< std::string,std::string > >::iterator last) -> std::vector< std::map< std::string,std::string > >::iterator
        """
        return _enigma.StringMapVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::map<(std::string,std::string)>)> self) -> StringMapVector
        __init__(std::vector<(std::map<(std::string,std::string)>)> self, StringMapVector arg2) -> StringMapVector
        __init__(std::vector<(std::map<(std::string,std::string)>)> self, std::vector< std::map< std::string,std::string > >::size_type size) -> StringMapVector
        __init__(std::vector<(std::map<(std::string,std::string)>)> self, std::vector< std::map< std::string,std::string > >::size_type size, StringMap value) -> StringMapVector
        """
        _enigma.StringMapVector_swiginit(self, _enigma.new_StringMapVector(*args))

    def push_back(self, x):
        """push_back(StringMapVector self, StringMap x)"""
        return _enigma.StringMapVector_push_back(self, x)


    def front(self):
        """front(StringMapVector self) -> StringMap"""
        return _enigma.StringMapVector_front(self)


    def back(self):
        """back(StringMapVector self) -> StringMap"""
        return _enigma.StringMapVector_back(self)


    def assign(self, n, x):
        """assign(StringMapVector self, std::vector< std::map< std::string,std::string > >::size_type n, StringMap x)"""
        return _enigma.StringMapVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(StringMapVector self, std::vector< std::map< std::string,std::string > >::size_type new_size)
        resize(StringMapVector self, std::vector< std::map< std::string,std::string > >::size_type new_size, StringMap x)
        """
        return _enigma.StringMapVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(StringMapVector self, std::vector< std::map< std::string,std::string > >::iterator pos, StringMap x) -> std::vector< std::map< std::string,std::string > >::iterator
        insert(StringMapVector self, std::vector< std::map< std::string,std::string > >::iterator pos, std::vector< std::map< std::string,std::string > >::size_type n, StringMap x)
        """
        return _enigma.StringMapVector_insert(self, *args)


    def reserve(self, n):
        """reserve(StringMapVector self, std::vector< std::map< std::string,std::string > >::size_type n)"""
        return _enigma.StringMapVector_reserve(self, n)


    def capacity(self):
        """capacity(StringMapVector self) -> std::vector< std::map< std::string,std::string > >::size_type"""
        return _enigma.StringMapVector_capacity(self)

    __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.__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.pop = new_instancemethod(_enigma.StringMapVector_pop, 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.swap = new_instancemethod(_enigma.StringMapVector_swap, 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.clear = new_instancemethod(_enigma.StringMapVector_clear, None, StringMapVector)
StringMapVector.get_allocator = new_instancemethod(_enigma.StringMapVector_get_allocator, 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):
    """Proxy of C++ std::vector<(std::string)> class."""

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

    def iterator(self):
        """iterator(StringVector self) -> SwigPyIterator"""
        return _enigma.StringVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(StringVector self) -> bool"""
        return _enigma.StringVector___nonzero__(self)


    def __bool__(self):
        """__bool__(StringVector self) -> bool"""
        return _enigma.StringVector___bool__(self)


    def __len__(self):
        """__len__(StringVector self) -> std::vector< std::string >::size_type"""
        return _enigma.StringVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StringVector"""
        return _enigma.StringVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, StringVector v)
        """
        return _enigma.StringVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _enigma.StringVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(StringVector self, std::vector< std::string >::difference_type i)
        __delitem__(StringVector self, PySliceObject * slice)
        """
        return _enigma.StringVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(StringVector self, PySliceObject * slice) -> StringVector
        __getitem__(StringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _enigma.StringVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(StringVector self, PySliceObject * slice, StringVector v)
        __setitem__(StringVector self, PySliceObject * slice)
        __setitem__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _enigma.StringVector___setitem__(self, *args)


    def pop(self):
        """pop(StringVector self) -> std::vector< std::string >::value_type"""
        return _enigma.StringVector_pop(self)


    def append(self, x):
        """append(StringVector self, std::vector< std::string >::value_type const & x)"""
        return _enigma.StringVector_append(self, x)


    def empty(self):
        """empty(StringVector self) -> bool"""
        return _enigma.StringVector_empty(self)


    def size(self):
        """size(StringVector self) -> std::vector< std::string >::size_type"""
        return _enigma.StringVector_size(self)


    def swap(self, v):
        """swap(StringVector self, StringVector v)"""
        return _enigma.StringVector_swap(self, v)


    def begin(self):
        """begin(StringVector self) -> std::vector< std::string >::iterator"""
        return _enigma.StringVector_begin(self)


    def end(self):
        """end(StringVector self) -> std::vector< std::string >::iterator"""
        return _enigma.StringVector_end(self)


    def rbegin(self):
        """rbegin(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _enigma.StringVector_rbegin(self)


    def rend(self):
        """rend(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _enigma.StringVector_rend(self)


    def clear(self):
        """clear(StringVector self)"""
        return _enigma.StringVector_clear(self)


    def get_allocator(self):
        """get_allocator(StringVector self) -> std::vector< std::string >::allocator_type"""
        return _enigma.StringVector_get_allocator(self)


    def pop_back(self):
        """pop_back(StringVector self)"""
        return _enigma.StringVector_pop_back(self)


    def erase(self, *args):
        """
        erase(StringVector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(StringVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _enigma.StringVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::string)> self) -> StringVector
        __init__(std::vector<(std::string)> self, StringVector arg2) -> StringVector
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> StringVector
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVector
        """
        _enigma.StringVector_swiginit(self, _enigma.new_StringVector(*args))

    def push_back(self, x):
        """push_back(StringVector self, std::vector< std::string >::value_type const & x)"""
        return _enigma.StringVector_push_back(self, x)


    def front(self):
        """front(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _enigma.StringVector_front(self)


    def back(self):
        """back(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _enigma.StringVector_back(self)


    def assign(self, n, x):
        """assign(StringVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _enigma.StringVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(StringVector self, std::vector< std::string >::size_type new_size)
        resize(StringVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _enigma.StringVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _enigma.StringVector_insert(self, *args)


    def reserve(self, n):
        """reserve(StringVector self, std::vector< std::string >::size_type n)"""
        return _enigma.StringVector_reserve(self, n)


    def capacity(self):
        """capacity(StringVector self) -> std::vector< std::string >::size_type"""
        return _enigma.StringVector_capacity(self)

    __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.__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.pop = new_instancemethod(_enigma.StringVector_pop, 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.swap = new_instancemethod(_enigma.StringVector_swap, 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.clear = new_instancemethod(_enigma.StringVector_clear, None, StringVector)
StringVector.get_allocator = new_instancemethod(_enigma.StringVector_get_allocator, 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):
    """Proxy of C++ std::list<(int)> class."""

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

    def iterator(self):
        """iterator(IntList self) -> SwigPyIterator"""
        return _enigma.IntList_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(IntList self) -> bool"""
        return _enigma.IntList___nonzero__(self)


    def __bool__(self):
        """__bool__(IntList self) -> bool"""
        return _enigma.IntList___bool__(self)


    def __len__(self):
        """__len__(IntList self) -> std::list< int >::size_type"""
        return _enigma.IntList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(IntList self, std::list< int >::difference_type i, std::list< int >::difference_type j) -> IntList"""
        return _enigma.IntList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(IntList self, std::list< int >::difference_type i, std::list< int >::difference_type j)
        __setslice__(IntList self, std::list< int >::difference_type i, std::list< int >::difference_type j, IntList v)
        """
        return _enigma.IntList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(IntList self, std::list< int >::difference_type i, std::list< int >::difference_type j)"""
        return _enigma.IntList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(IntList self, std::list< int >::difference_type i)
        __delitem__(IntList self, PySliceObject * slice)
        """
        return _enigma.IntList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(IntList self, PySliceObject * slice) -> IntList
        __getitem__(IntList self, std::list< int >::difference_type i) -> std::list< int >::value_type const &
        """
        return _enigma.IntList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(IntList self, PySliceObject * slice, IntList v)
        __setitem__(IntList self, PySliceObject * slice)
        __setitem__(IntList self, std::list< int >::difference_type i, std::list< int >::value_type const & x)
        """
        return _enigma.IntList___setitem__(self, *args)


    def pop(self):
        """pop(IntList self) -> std::list< int >::value_type"""
        return _enigma.IntList_pop(self)


    def append(self, x):
        """append(IntList self, std::list< int >::value_type const & x)"""
        return _enigma.IntList_append(self, x)


    def empty(self):
        """empty(IntList self) -> bool"""
        return _enigma.IntList_empty(self)


    def size(self):
        """size(IntList self) -> std::list< int >::size_type"""
        return _enigma.IntList_size(self)


    def swap(self, v):
        """swap(IntList self, IntList v)"""
        return _enigma.IntList_swap(self, v)


    def begin(self):
        """begin(IntList self) -> std::list< int >::iterator"""
        return _enigma.IntList_begin(self)


    def end(self):
        """end(IntList self) -> std::list< int >::iterator"""
        return _enigma.IntList_end(self)


    def rbegin(self):
        """rbegin(IntList self) -> std::list< int >::reverse_iterator"""
        return _enigma.IntList_rbegin(self)


    def rend(self):
        """rend(IntList self) -> std::list< int >::reverse_iterator"""
        return _enigma.IntList_rend(self)


    def clear(self):
        """clear(IntList self)"""
        return _enigma.IntList_clear(self)


    def get_allocator(self):
        """get_allocator(IntList self) -> std::list< int >::allocator_type"""
        return _enigma.IntList_get_allocator(self)


    def pop_back(self):
        """pop_back(IntList self)"""
        return _enigma.IntList_pop_back(self)


    def erase(self, *args):
        """
        erase(IntList self, std::list< int >::iterator pos) -> std::list< int >::iterator
        erase(IntList self, std::list< int >::iterator first, std::list< int >::iterator last) -> std::list< int >::iterator
        """
        return _enigma.IntList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(int)> self) -> IntList
        __init__(std::list<(int)> self, IntList arg2) -> IntList
        __init__(std::list<(int)> self, std::list< int >::size_type size) -> IntList
        __init__(std::list<(int)> self, std::list< int >::size_type size, std::list< int >::value_type const & value) -> IntList
        """
        _enigma.IntList_swiginit(self, _enigma.new_IntList(*args))

    def push_back(self, x):
        """push_back(IntList self, std::list< int >::value_type const & x)"""
        return _enigma.IntList_push_back(self, x)


    def front(self):
        """front(IntList self) -> std::list< int >::value_type const &"""
        return _enigma.IntList_front(self)


    def back(self):
        """back(IntList self) -> std::list< int >::value_type const &"""
        return _enigma.IntList_back(self)


    def assign(self, n, x):
        """assign(IntList self, std::list< int >::size_type n, std::list< int >::value_type const & x)"""
        return _enigma.IntList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(IntList self, std::list< int >::size_type new_size)
        resize(IntList self, std::list< int >::size_type new_size, std::list< int >::value_type const & x)
        """
        return _enigma.IntList_resize(self, *args)


    def insert(self, *args):
        """
        insert(IntList self, std::list< int >::iterator pos, std::list< int >::value_type const & x) -> std::list< int >::iterator
        insert(IntList self, std::list< int >::iterator pos, std::list< int >::size_type n, std::list< int >::value_type const & x)
        """
        return _enigma.IntList_insert(self, *args)


    def pop_front(self):
        """pop_front(IntList self)"""
        return _enigma.IntList_pop_front(self)


    def push_front(self, x):
        """push_front(IntList self, std::list< int >::value_type const & x)"""
        return _enigma.IntList_push_front(self, x)


    def reverse(self):
        """reverse(IntList self)"""
        return _enigma.IntList_reverse(self)

    __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.__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.pop = new_instancemethod(_enigma.IntList_pop, 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.swap = new_instancemethod(_enigma.IntList_swap, 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.clear = new_instancemethod(_enigma.IntList_clear, None, IntList)
IntList.get_allocator = new_instancemethod(_enigma.IntList_get_allocator, 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 IntVector(object):
    """Proxy of C++ std::vector<(int)> class."""

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

    def iterator(self):
        """iterator(IntVector self) -> SwigPyIterator"""
        return _enigma.IntVector_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(IntVector self) -> bool"""
        return _enigma.IntVector___nonzero__(self)


    def __bool__(self):
        """__bool__(IntVector self) -> bool"""
        return _enigma.IntVector___bool__(self)


    def __len__(self):
        """__len__(IntVector self) -> std::vector< int >::size_type"""
        return _enigma.IntVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> IntVector"""
        return _enigma.IntVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, IntVector v)
        """
        return _enigma.IntVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _enigma.IntVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(IntVector self, std::vector< int >::difference_type i)
        __delitem__(IntVector self, PySliceObject * slice)
        """
        return _enigma.IntVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(IntVector self, PySliceObject * slice) -> IntVector
        __getitem__(IntVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _enigma.IntVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(IntVector self, PySliceObject * slice, IntVector v)
        __setitem__(IntVector self, PySliceObject * slice)
        __setitem__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _enigma.IntVector___setitem__(self, *args)


    def pop(self):
        """pop(IntVector self) -> std::vector< int >::value_type"""
        return _enigma.IntVector_pop(self)


    def append(self, x):
        """append(IntVector self, std::vector< int >::value_type const & x)"""
        return _enigma.IntVector_append(self, x)


    def empty(self):
        """empty(IntVector self) -> bool"""
        return _enigma.IntVector_empty(self)


    def size(self):
        """size(IntVector self) -> std::vector< int >::size_type"""
        return _enigma.IntVector_size(self)


    def swap(self, v):
        """swap(IntVector self, IntVector v)"""
        return _enigma.IntVector_swap(self, v)


    def begin(self):
        """begin(IntVector self) -> std::vector< int >::iterator"""
        return _enigma.IntVector_begin(self)


    def end(self):
        """end(IntVector self) -> std::vector< int >::iterator"""
        return _enigma.IntVector_end(self)


    def rbegin(self):
        """rbegin(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _enigma.IntVector_rbegin(self)


    def rend(self):
        """rend(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _enigma.IntVector_rend(self)


    def clear(self):
        """clear(IntVector self)"""
        return _enigma.IntVector_clear(self)


    def get_allocator(self):
        """get_allocator(IntVector self) -> std::vector< int >::allocator_type"""
        return _enigma.IntVector_get_allocator(self)


    def pop_back(self):
        """pop_back(IntVector self)"""
        return _enigma.IntVector_pop_back(self)


    def erase(self, *args):
        """
        erase(IntVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(IntVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _enigma.IntVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int)> self) -> IntVector
        __init__(std::vector<(int)> self, IntVector arg2) -> IntVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> IntVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
        """
        _enigma.IntVector_swiginit(self, _enigma.new_IntVector(*args))

    def push_back(self, x):
        """push_back(IntVector self, std::vector< int >::value_type const & x)"""
        return _enigma.IntVector_push_back(self, x)


    def front(self):
        """front(IntVector self) -> std::vector< int >::value_type const &"""
        return _enigma.IntVector_front(self)


    def back(self):
        """back(IntVector self) -> std::vector< int >::value_type const &"""
        return _enigma.IntVector_back(self)


    def assign(self, n, x):
        """assign(IntVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _enigma.IntVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(IntVector self, std::vector< int >::size_type new_size)
        resize(IntVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _enigma.IntVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _enigma.IntVector_insert(self, *args)


    def reserve(self, n):
        """reserve(IntVector self, std::vector< int >::size_type n)"""
        return _enigma.IntVector_reserve(self, n)


    def capacity(self):
        """capacity(IntVector self) -> std::vector< int >::size_type"""
        return _enigma.IntVector_capacity(self)

    __swig_destroy__ = _enigma.delete_IntVector
IntVector.iterator = new_instancemethod(_enigma.IntVector_iterator, None, IntVector)
IntVector.__nonzero__ = new_instancemethod(_enigma.IntVector___nonzero__, None, IntVector)
IntVector.__bool__ = new_instancemethod(_enigma.IntVector___bool__, None, IntVector)
IntVector.__len__ = new_instancemethod(_enigma.IntVector___len__, None, IntVector)
IntVector.__getslice__ = new_instancemethod(_enigma.IntVector___getslice__, None, IntVector)
IntVector.__setslice__ = new_instancemethod(_enigma.IntVector___setslice__, None, IntVector)
IntVector.__delslice__ = new_instancemethod(_enigma.IntVector___delslice__, None, IntVector)
IntVector.__delitem__ = new_instancemethod(_enigma.IntVector___delitem__, None, IntVector)
IntVector.__getitem__ = new_instancemethod(_enigma.IntVector___getitem__, None, IntVector)
IntVector.__setitem__ = new_instancemethod(_enigma.IntVector___setitem__, None, IntVector)
IntVector.pop = new_instancemethod(_enigma.IntVector_pop, None, IntVector)
IntVector.append = new_instancemethod(_enigma.IntVector_append, None, IntVector)
IntVector.empty = new_instancemethod(_enigma.IntVector_empty, None, IntVector)
IntVector.size = new_instancemethod(_enigma.IntVector_size, None, IntVector)
IntVector.swap = new_instancemethod(_enigma.IntVector_swap, None, IntVector)
IntVector.begin = new_instancemethod(_enigma.IntVector_begin, None, IntVector)
IntVector.end = new_instancemethod(_enigma.IntVector_end, None, IntVector)
IntVector.rbegin = new_instancemethod(_enigma.IntVector_rbegin, None, IntVector)
IntVector.rend = new_instancemethod(_enigma.IntVector_rend, None, IntVector)
IntVector.clear = new_instancemethod(_enigma.IntVector_clear, None, IntVector)
IntVector.get_allocator = new_instancemethod(_enigma.IntVector_get_allocator, None, IntVector)
IntVector.pop_back = new_instancemethod(_enigma.IntVector_pop_back, None, IntVector)
IntVector.erase = new_instancemethod(_enigma.IntVector_erase, None, IntVector)
IntVector.push_back = new_instancemethod(_enigma.IntVector_push_back, None, IntVector)
IntVector.front = new_instancemethod(_enigma.IntVector_front, None, IntVector)
IntVector.back = new_instancemethod(_enigma.IntVector_back, None, IntVector)
IntVector.assign = new_instancemethod(_enigma.IntVector_assign, None, IntVector)
IntVector.resize = new_instancemethod(_enigma.IntVector_resize, None, IntVector)
IntVector.insert = new_instancemethod(_enigma.IntVector_insert, None, IntVector)
IntVector.reserve = new_instancemethod(_enigma.IntVector_reserve, None, IntVector)
IntVector.capacity = new_instancemethod(_enigma.IntVector_capacity, None, IntVector)
IntVector_swigregister = _enigma.IntVector_swigregister
IntVector_swigregister(IntVector)

class WindowAnimationSetMap(object):
    """Proxy of C++ std::map<(std::string,ePtr<(eWindowAnimationSet)>)> class."""

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

    def iterator(self):
        """iterator(WindowAnimationSetMap self) -> SwigPyIterator"""
        return _enigma.WindowAnimationSetMap_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(WindowAnimationSetMap self) -> bool"""
        return _enigma.WindowAnimationSetMap___nonzero__(self)


    def __bool__(self):
        """__bool__(WindowAnimationSetMap self) -> bool"""
        return _enigma.WindowAnimationSetMap___bool__(self)


    def __len__(self):
        """__len__(WindowAnimationSetMap self) -> std::map< std::string,ePtr< eWindowAnimationSet > >::size_type"""
        return _enigma.WindowAnimationSetMap___len__(self)

    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 __getitem__(self, key):
        """__getitem__(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & key) -> eWindowAnimationSet"""
        return _enigma.WindowAnimationSetMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & key)"""
        return _enigma.WindowAnimationSetMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & key) -> bool"""
        return _enigma.WindowAnimationSetMap_has_key(self, key)


    def keys(self):
        """keys(WindowAnimationSetMap self) -> PyObject *"""
        return _enigma.WindowAnimationSetMap_keys(self)


    def values(self):
        """values(WindowAnimationSetMap self) -> PyObject *"""
        return _enigma.WindowAnimationSetMap_values(self)


    def items(self):
        """items(WindowAnimationSetMap self) -> PyObject *"""
        return _enigma.WindowAnimationSetMap_items(self)


    def __contains__(self, key):
        """__contains__(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & key) -> bool"""
        return _enigma.WindowAnimationSetMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(WindowAnimationSetMap self) -> SwigPyIterator"""
        return _enigma.WindowAnimationSetMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(WindowAnimationSetMap self) -> SwigPyIterator"""
        return _enigma.WindowAnimationSetMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & key)
        __setitem__(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & key, eWindowAnimationSet x)
        """
        return _enigma.WindowAnimationSetMap___setitem__(self, *args)


    def asdict(self):
        """asdict(WindowAnimationSetMap self) -> PyObject *"""
        return _enigma.WindowAnimationSetMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,ePtr<(eWindowAnimationSet)>)> self, std::less< std::string > const & arg2) -> WindowAnimationSetMap
        __init__(std::map<(std::string,ePtr<(eWindowAnimationSet)>)> self) -> WindowAnimationSetMap
        __init__(std::map<(std::string,ePtr<(eWindowAnimationSet)>)> self, WindowAnimationSetMap arg2) -> WindowAnimationSetMap
        """
        _enigma.WindowAnimationSetMap_swiginit(self, _enigma.new_WindowAnimationSetMap(*args))

    def empty(self):
        """empty(WindowAnimationSetMap self) -> bool"""
        return _enigma.WindowAnimationSetMap_empty(self)


    def size(self):
        """size(WindowAnimationSetMap self) -> std::map< std::string,ePtr< eWindowAnimationSet > >::size_type"""
        return _enigma.WindowAnimationSetMap_size(self)


    def swap(self, v):
        """swap(WindowAnimationSetMap self, WindowAnimationSetMap v)"""
        return _enigma.WindowAnimationSetMap_swap(self, v)


    def begin(self):
        """begin(WindowAnimationSetMap self) -> std::map< std::string,ePtr< eWindowAnimationSet > >::iterator"""
        return _enigma.WindowAnimationSetMap_begin(self)


    def end(self):
        """end(WindowAnimationSetMap self) -> std::map< std::string,ePtr< eWindowAnimationSet > >::iterator"""
        return _enigma.WindowAnimationSetMap_end(self)


    def rbegin(self):
        """rbegin(WindowAnimationSetMap self) -> std::map< std::string,ePtr< eWindowAnimationSet > >::reverse_iterator"""
        return _enigma.WindowAnimationSetMap_rbegin(self)


    def rend(self):
        """rend(WindowAnimationSetMap self) -> std::map< std::string,ePtr< eWindowAnimationSet > >::reverse_iterator"""
        return _enigma.WindowAnimationSetMap_rend(self)


    def clear(self):
        """clear(WindowAnimationSetMap self)"""
        return _enigma.WindowAnimationSetMap_clear(self)


    def get_allocator(self):
        """get_allocator(WindowAnimationSetMap self) -> std::map< std::string,ePtr< eWindowAnimationSet > >::allocator_type"""
        return _enigma.WindowAnimationSetMap_get_allocator(self)


    def count(self, x):
        """count(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & x) -> std::map< std::string,ePtr< eWindowAnimationSet > >::size_type"""
        return _enigma.WindowAnimationSetMap_count(self, x)


    def erase(self, *args):
        """
        erase(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & x) -> std::map< std::string,ePtr< eWindowAnimationSet > >::size_type
        erase(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::iterator position)
        erase(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::iterator first, std::map< std::string,ePtr< eWindowAnimationSet > >::iterator last)
        """
        return _enigma.WindowAnimationSetMap_erase(self, *args)


    def find(self, x):
        """find(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & x) -> std::map< std::string,ePtr< eWindowAnimationSet > >::iterator"""
        return _enigma.WindowAnimationSetMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & x) -> std::map< std::string,ePtr< eWindowAnimationSet > >::iterator"""
        return _enigma.WindowAnimationSetMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(WindowAnimationSetMap self, std::map< std::string,ePtr< eWindowAnimationSet > >::key_type const & x) -> std::map< std::string,ePtr< eWindowAnimationSet > >::iterator"""
        return _enigma.WindowAnimationSetMap_upper_bound(self, x)

    __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.swap = new_instancemethod(_enigma.WindowAnimationSetMap_swap, 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.clear = new_instancemethod(_enigma.WindowAnimationSetMap_clear, None, WindowAnimationSetMap)
WindowAnimationSetMap.get_allocator = new_instancemethod(_enigma.WindowAnimationSetMap_get_allocator, 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)

class eVideoModes(object):
    """Proxy of C++ std::list<(eVideoMode)> class."""

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

    def iterator(self):
        """iterator(eVideoModes self) -> SwigPyIterator"""
        return _enigma.eVideoModes_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(eVideoModes self) -> bool"""
        return _enigma.eVideoModes___nonzero__(self)


    def __bool__(self):
        """__bool__(eVideoModes self) -> bool"""
        return _enigma.eVideoModes___bool__(self)


    def __len__(self):
        """__len__(eVideoModes self) -> std::list< _eVideoMode >::size_type"""
        return _enigma.eVideoModes___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(eVideoModes self, std::list< _eVideoMode >::difference_type i, std::list< _eVideoMode >::difference_type j) -> eVideoModes"""
        return _enigma.eVideoModes___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(eVideoModes self, std::list< _eVideoMode >::difference_type i, std::list< _eVideoMode >::difference_type j)
        __setslice__(eVideoModes self, std::list< _eVideoMode >::difference_type i, std::list< _eVideoMode >::difference_type j, eVideoModes v)
        """
        return _enigma.eVideoModes___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(eVideoModes self, std::list< _eVideoMode >::difference_type i, std::list< _eVideoMode >::difference_type j)"""
        return _enigma.eVideoModes___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(eVideoModes self, std::list< _eVideoMode >::difference_type i)
        __delitem__(eVideoModes self, PySliceObject * slice)
        """
        return _enigma.eVideoModes___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(eVideoModes self, PySliceObject * slice) -> eVideoModes
        __getitem__(eVideoModes self, std::list< _eVideoMode >::difference_type i) -> eVideoMode
        """
        return _enigma.eVideoModes___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(eVideoModes self, PySliceObject * slice, eVideoModes v)
        __setitem__(eVideoModes self, PySliceObject * slice)
        __setitem__(eVideoModes self, std::list< _eVideoMode >::difference_type i, eVideoMode x)
        """
        return _enigma.eVideoModes___setitem__(self, *args)


    def pop(self):
        """pop(eVideoModes self) -> eVideoMode"""
        return _enigma.eVideoModes_pop(self)


    def append(self, x):
        """append(eVideoModes self, eVideoMode x)"""
        return _enigma.eVideoModes_append(self, x)


    def empty(self):
        """empty(eVideoModes self) -> bool"""
        return _enigma.eVideoModes_empty(self)


    def size(self):
        """size(eVideoModes self) -> std::list< _eVideoMode >::size_type"""
        return _enigma.eVideoModes_size(self)


    def swap(self, v):
        """swap(eVideoModes self, eVideoModes v)"""
        return _enigma.eVideoModes_swap(self, v)


    def begin(self):
        """begin(eVideoModes self) -> std::list< _eVideoMode >::iterator"""
        return _enigma.eVideoModes_begin(self)


    def end(self):
        """end(eVideoModes self) -> std::list< _eVideoMode >::iterator"""
        return _enigma.eVideoModes_end(self)


    def rbegin(self):
        """rbegin(eVideoModes self) -> std::list< _eVideoMode >::reverse_iterator"""
        return _enigma.eVideoModes_rbegin(self)


    def rend(self):
        """rend(eVideoModes self) -> std::list< _eVideoMode >::reverse_iterator"""
        return _enigma.eVideoModes_rend(self)


    def clear(self):
        """clear(eVideoModes self)"""
        return _enigma.eVideoModes_clear(self)


    def get_allocator(self):
        """get_allocator(eVideoModes self) -> std::list< _eVideoMode >::allocator_type"""
        return _enigma.eVideoModes_get_allocator(self)


    def pop_back(self):
        """pop_back(eVideoModes self)"""
        return _enigma.eVideoModes_pop_back(self)


    def erase(self, *args):
        """
        erase(eVideoModes self, std::list< _eVideoMode >::iterator pos) -> std::list< _eVideoMode >::iterator
        erase(eVideoModes self, std::list< _eVideoMode >::iterator first, std::list< _eVideoMode >::iterator last) -> std::list< _eVideoMode >::iterator
        """
        return _enigma.eVideoModes_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(eVideoMode)> self) -> eVideoModes
        __init__(std::list<(eVideoMode)> self, eVideoModes arg2) -> eVideoModes
        __init__(std::list<(eVideoMode)> self, std::list< _eVideoMode >::size_type size) -> eVideoModes
        __init__(std::list<(eVideoMode)> self, std::list< _eVideoMode >::size_type size, eVideoMode value) -> eVideoModes
        """
        _enigma.eVideoModes_swiginit(self, _enigma.new_eVideoModes(*args))

    def push_back(self, x):
        """push_back(eVideoModes self, eVideoMode x)"""
        return _enigma.eVideoModes_push_back(self, x)


    def front(self):
        """front(eVideoModes self) -> eVideoMode"""
        return _enigma.eVideoModes_front(self)


    def back(self):
        """back(eVideoModes self) -> eVideoMode"""
        return _enigma.eVideoModes_back(self)


    def assign(self, n, x):
        """assign(eVideoModes self, std::list< _eVideoMode >::size_type n, eVideoMode x)"""
        return _enigma.eVideoModes_assign(self, n, x)


    def resize(self, *args):
        """
        resize(eVideoModes self, std::list< _eVideoMode >::size_type new_size)
        resize(eVideoModes self, std::list< _eVideoMode >::size_type new_size, eVideoMode x)
        """
        return _enigma.eVideoModes_resize(self, *args)


    def insert(self, *args):
        """
        insert(eVideoModes self, std::list< _eVideoMode >::iterator pos, eVideoMode x) -> std::list< _eVideoMode >::iterator
        insert(eVideoModes self, std::list< _eVideoMode >::iterator pos, std::list< _eVideoMode >::size_type n, eVideoMode x)
        """
        return _enigma.eVideoModes_insert(self, *args)


    def pop_front(self):
        """pop_front(eVideoModes self)"""
        return _enigma.eVideoModes_pop_front(self)


    def push_front(self, x):
        """push_front(eVideoModes self, eVideoMode x)"""
        return _enigma.eVideoModes_push_front(self, x)


    def reverse(self):
        """reverse(eVideoModes self)"""
        return _enigma.eVideoModes_reverse(self)

    __swig_destroy__ = _enigma.delete_eVideoModes
eVideoModes.iterator = new_instancemethod(_enigma.eVideoModes_iterator, None, eVideoModes)
eVideoModes.__nonzero__ = new_instancemethod(_enigma.eVideoModes___nonzero__, None, eVideoModes)
eVideoModes.__bool__ = new_instancemethod(_enigma.eVideoModes___bool__, None, eVideoModes)
eVideoModes.__len__ = new_instancemethod(_enigma.eVideoModes___len__, None, eVideoModes)
eVideoModes.__getslice__ = new_instancemethod(_enigma.eVideoModes___getslice__, None, eVideoModes)
eVideoModes.__setslice__ = new_instancemethod(_enigma.eVideoModes___setslice__, None, eVideoModes)
eVideoModes.__delslice__ = new_instancemethod(_enigma.eVideoModes___delslice__, None, eVideoModes)
eVideoModes.__delitem__ = new_instancemethod(_enigma.eVideoModes___delitem__, None, eVideoModes)
eVideoModes.__getitem__ = new_instancemethod(_enigma.eVideoModes___getitem__, None, eVideoModes)
eVideoModes.__setitem__ = new_instancemethod(_enigma.eVideoModes___setitem__, None, eVideoModes)
eVideoModes.pop = new_instancemethod(_enigma.eVideoModes_pop, None, eVideoModes)
eVideoModes.append = new_instancemethod(_enigma.eVideoModes_append, None, eVideoModes)
eVideoModes.empty = new_instancemethod(_enigma.eVideoModes_empty, None, eVideoModes)
eVideoModes.size = new_instancemethod(_enigma.eVideoModes_size, None, eVideoModes)
eVideoModes.swap = new_instancemethod(_enigma.eVideoModes_swap, None, eVideoModes)
eVideoModes.begin = new_instancemethod(_enigma.eVideoModes_begin, None, eVideoModes)
eVideoModes.end = new_instancemethod(_enigma.eVideoModes_end, None, eVideoModes)
eVideoModes.rbegin = new_instancemethod(_enigma.eVideoModes_rbegin, None, eVideoModes)
eVideoModes.rend = new_instancemethod(_enigma.eVideoModes_rend, None, eVideoModes)
eVideoModes.clear = new_instancemethod(_enigma.eVideoModes_clear, None, eVideoModes)
eVideoModes.get_allocator = new_instancemethod(_enigma.eVideoModes_get_allocator, None, eVideoModes)
eVideoModes.pop_back = new_instancemethod(_enigma.eVideoModes_pop_back, None, eVideoModes)
eVideoModes.erase = new_instancemethod(_enigma.eVideoModes_erase, None, eVideoModes)
eVideoModes.push_back = new_instancemethod(_enigma.eVideoModes_push_back, None, eVideoModes)
eVideoModes.front = new_instancemethod(_enigma.eVideoModes_front, None, eVideoModes)
eVideoModes.back = new_instancemethod(_enigma.eVideoModes_back, None, eVideoModes)
eVideoModes.assign = new_instancemethod(_enigma.eVideoModes_assign, None, eVideoModes)
eVideoModes.resize = new_instancemethod(_enigma.eVideoModes_resize, None, eVideoModes)
eVideoModes.insert = new_instancemethod(_enigma.eVideoModes_insert, None, eVideoModes)
eVideoModes.pop_front = new_instancemethod(_enigma.eVideoModes_pop_front, None, eVideoModes)
eVideoModes.push_front = new_instancemethod(_enigma.eVideoModes_push_front, None, eVideoModes)
eVideoModes.reverse = new_instancemethod(_enigma.eVideoModes_reverse, None, eVideoModes)
eVideoModes_swigregister = _enigma.eVideoModes_swigregister
eVideoModes_swigregister(eVideoModes)

class eVideoPorts(object):
    """Proxy of C++ std::map<(std::string,eVideoPort)> class."""

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

    def iterator(self):
        """iterator(eVideoPorts self) -> SwigPyIterator"""
        return _enigma.eVideoPorts_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(eVideoPorts self) -> bool"""
        return _enigma.eVideoPorts___nonzero__(self)


    def __bool__(self):
        """__bool__(eVideoPorts self) -> bool"""
        return _enigma.eVideoPorts___bool__(self)


    def __len__(self):
        """__len__(eVideoPorts self) -> std::map< std::string,_eVideoPort >::size_type"""
        return _enigma.eVideoPorts___len__(self)

    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 __getitem__(self, key):
        """__getitem__(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & key) -> eVideoPort"""
        return _enigma.eVideoPorts___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & key)"""
        return _enigma.eVideoPorts___delitem__(self, key)


    def has_key(self, key):
        """has_key(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & key) -> bool"""
        return _enigma.eVideoPorts_has_key(self, key)


    def keys(self):
        """keys(eVideoPorts self) -> PyObject *"""
        return _enigma.eVideoPorts_keys(self)


    def values(self):
        """values(eVideoPorts self) -> PyObject *"""
        return _enigma.eVideoPorts_values(self)


    def items(self):
        """items(eVideoPorts self) -> PyObject *"""
        return _enigma.eVideoPorts_items(self)


    def __contains__(self, key):
        """__contains__(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & key) -> bool"""
        return _enigma.eVideoPorts___contains__(self, key)


    def key_iterator(self):
        """key_iterator(eVideoPorts self) -> SwigPyIterator"""
        return _enigma.eVideoPorts_key_iterator(self)


    def value_iterator(self):
        """value_iterator(eVideoPorts self) -> SwigPyIterator"""
        return _enigma.eVideoPorts_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & key)
        __setitem__(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & key, eVideoPort x)
        """
        return _enigma.eVideoPorts___setitem__(self, *args)


    def asdict(self):
        """asdict(eVideoPorts self) -> PyObject *"""
        return _enigma.eVideoPorts_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,eVideoPort)> self, std::less< std::string > const & arg2) -> eVideoPorts
        __init__(std::map<(std::string,eVideoPort)> self) -> eVideoPorts
        __init__(std::map<(std::string,eVideoPort)> self, eVideoPorts arg2) -> eVideoPorts
        """
        _enigma.eVideoPorts_swiginit(self, _enigma.new_eVideoPorts(*args))

    def empty(self):
        """empty(eVideoPorts self) -> bool"""
        return _enigma.eVideoPorts_empty(self)


    def size(self):
        """size(eVideoPorts self) -> std::map< std::string,_eVideoPort >::size_type"""
        return _enigma.eVideoPorts_size(self)


    def swap(self, v):
        """swap(eVideoPorts self, eVideoPorts v)"""
        return _enigma.eVideoPorts_swap(self, v)


    def begin(self):
        """begin(eVideoPorts self) -> std::map< std::string,_eVideoPort >::iterator"""
        return _enigma.eVideoPorts_begin(self)


    def end(self):
        """end(eVideoPorts self) -> std::map< std::string,_eVideoPort >::iterator"""
        return _enigma.eVideoPorts_end(self)


    def rbegin(self):
        """rbegin(eVideoPorts self) -> std::map< std::string,_eVideoPort >::reverse_iterator"""
        return _enigma.eVideoPorts_rbegin(self)


    def rend(self):
        """rend(eVideoPorts self) -> std::map< std::string,_eVideoPort >::reverse_iterator"""
        return _enigma.eVideoPorts_rend(self)


    def clear(self):
        """clear(eVideoPorts self)"""
        return _enigma.eVideoPorts_clear(self)


    def get_allocator(self):
        """get_allocator(eVideoPorts self) -> std::map< std::string,_eVideoPort >::allocator_type"""
        return _enigma.eVideoPorts_get_allocator(self)


    def count(self, x):
        """count(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & x) -> std::map< std::string,_eVideoPort >::size_type"""
        return _enigma.eVideoPorts_count(self, x)


    def erase(self, *args):
        """
        erase(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & x) -> std::map< std::string,_eVideoPort >::size_type
        erase(eVideoPorts self, std::map< std::string,_eVideoPort >::iterator position)
        erase(eVideoPorts self, std::map< std::string,_eVideoPort >::iterator first, std::map< std::string,_eVideoPort >::iterator last)
        """
        return _enigma.eVideoPorts_erase(self, *args)


    def find(self, x):
        """find(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & x) -> std::map< std::string,_eVideoPort >::iterator"""
        return _enigma.eVideoPorts_find(self, x)


    def lower_bound(self, x):
        """lower_bound(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & x) -> std::map< std::string,_eVideoPort >::iterator"""
        return _enigma.eVideoPorts_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(eVideoPorts self, std::map< std::string,_eVideoPort >::key_type const & x) -> std::map< std::string,_eVideoPort >::iterator"""
        return _enigma.eVideoPorts_upper_bound(self, x)

    __swig_destroy__ = _enigma.delete_eVideoPorts
eVideoPorts.iterator = new_instancemethod(_enigma.eVideoPorts_iterator, None, eVideoPorts)
eVideoPorts.__nonzero__ = new_instancemethod(_enigma.eVideoPorts___nonzero__, None, eVideoPorts)
eVideoPorts.__bool__ = new_instancemethod(_enigma.eVideoPorts___bool__, None, eVideoPorts)
eVideoPorts.__len__ = new_instancemethod(_enigma.eVideoPorts___len__, None, eVideoPorts)
eVideoPorts.__getitem__ = new_instancemethod(_enigma.eVideoPorts___getitem__, None, eVideoPorts)
eVideoPorts.__delitem__ = new_instancemethod(_enigma.eVideoPorts___delitem__, None, eVideoPorts)
eVideoPorts.has_key = new_instancemethod(_enigma.eVideoPorts_has_key, None, eVideoPorts)
eVideoPorts.keys = new_instancemethod(_enigma.eVideoPorts_keys, None, eVideoPorts)
eVideoPorts.values = new_instancemethod(_enigma.eVideoPorts_values, None, eVideoPorts)
eVideoPorts.items = new_instancemethod(_enigma.eVideoPorts_items, None, eVideoPorts)
eVideoPorts.__contains__ = new_instancemethod(_enigma.eVideoPorts___contains__, None, eVideoPorts)
eVideoPorts.key_iterator = new_instancemethod(_enigma.eVideoPorts_key_iterator, None, eVideoPorts)
eVideoPorts.value_iterator = new_instancemethod(_enigma.eVideoPorts_value_iterator, None, eVideoPorts)
eVideoPorts.__setitem__ = new_instancemethod(_enigma.eVideoPorts___setitem__, None, eVideoPorts)
eVideoPorts.asdict = new_instancemethod(_enigma.eVideoPorts_asdict, None, eVideoPorts)
eVideoPorts.empty = new_instancemethod(_enigma.eVideoPorts_empty, None, eVideoPorts)
eVideoPorts.size = new_instancemethod(_enigma.eVideoPorts_size, None, eVideoPorts)
eVideoPorts.swap = new_instancemethod(_enigma.eVideoPorts_swap, None, eVideoPorts)
eVideoPorts.begin = new_instancemethod(_enigma.eVideoPorts_begin, None, eVideoPorts)
eVideoPorts.end = new_instancemethod(_enigma.eVideoPorts_end, None, eVideoPorts)
eVideoPorts.rbegin = new_instancemethod(_enigma.eVideoPorts_rbegin, None, eVideoPorts)
eVideoPorts.rend = new_instancemethod(_enigma.eVideoPorts_rend, None, eVideoPorts)
eVideoPorts.clear = new_instancemethod(_enigma.eVideoPorts_clear, None, eVideoPorts)
eVideoPorts.get_allocator = new_instancemethod(_enigma.eVideoPorts_get_allocator, None, eVideoPorts)
eVideoPorts.count = new_instancemethod(_enigma.eVideoPorts_count, None, eVideoPorts)
eVideoPorts.erase = new_instancemethod(_enigma.eVideoPorts_erase, None, eVideoPorts)
eVideoPorts.find = new_instancemethod(_enigma.eVideoPorts_find, None, eVideoPorts)
eVideoPorts.lower_bound = new_instancemethod(_enigma.eVideoPorts_lower_bound, None, eVideoPorts)
eVideoPorts.upper_bound = new_instancemethod(_enigma.eVideoPorts_upper_bound, None, eVideoPorts)
eVideoPorts_swigregister = _enigma.eVideoPorts_swigregister
eVideoPorts_swigregister(eVideoPorts)


"""
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 six

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:
            meth_self = six.get_method_self(function)
            if meth_self is not None:
# bound method
                self._obj = weakref.ref(meth_self)
            else:
# unbound method
                self._obj = None
            self._func = six.get_method_function(function)
        except AttributeError:
# not a method
            self._obj = None
            self._func = function

    def __call__( self, *args, **kwargs ):
        """
        @return Calls a new bound-method like the original, or
        the original function if refers just to a function or
        unbound method and returns its result.
        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 = six.create_bound_method(self._func, self._obj())
        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) )

def eServiceReference_create(refstr):
    return eServiceReference(refstr)

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

    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):
        """__init__(eSlot self) -> eSlot"""
        _enigma.eSlot_swiginit(self, _enigma.new_eSlot())
eSlot_swigregister = _enigma.eSlot_swigregister
eSlot_swigregister(eSlot)

class eSlot0X(eSlot):
    """Proxy of C++ eSlot0<(void)> class."""

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

    def cb_func(self):
        """cb_func(eSlot0X self)"""
        return _enigma.eSlot0X_cb_func(self)


    def __init__(self):
        """__init__(eSlot0<(void)> self) -> eSlot0X"""
        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):
    """Proxy of C++ eSignal0<(void)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal0X self, eSlot0X slot)"""
        return _enigma.eSignal0X_connect2(self, slot)


    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):
        """__init__(eSignal0<(void)> self) -> eSignal0X"""
        _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):
    """Proxy of C++ eSlot1<(void,boost::any)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1Any self, boost::any arg0)"""
        return _enigma.eSlot1Any_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,boost::any)> self) -> eSlot1Any"""
        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):
    """Proxy of C++ eSignal1<(void,boost::any)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1Any self, eSlot1Any slot)"""
        return _enigma.eSignal1Any_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,boost::any)> self) -> eSignal1Any"""
        _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):
    """Proxy of C++ eSlot1<(void,int)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1I self, int arg0)"""
        return _enigma.eSlot1I_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,int)> self) -> eSlot1I"""
        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):
    """Proxy of C++ eSignal1<(void,int)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1I self, eSlot1I slot)"""
        return _enigma.eSignal1I_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,int)> self) -> eSignal1I"""
        _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):
    """Proxy of C++ eSlot1<(void,p.q(const).char)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1CStr self, char const * arg0)"""
        return _enigma.eSlot1CStr_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,p.q(const).char)> self) -> eSlot1CStr"""
        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):
    """Proxy of C++ eSignal1<(void,p.q(const).char)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1CStr self, eSlot1CStr slot)"""
        return _enigma.eSignal1CStr_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,p.q(const).char)> self) -> eSignal1CStr"""
        _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):
    """Proxy of C++ eSlot1<(void,long long)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1LL self, long long arg0)"""
        return _enigma.eSlot1LL_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,long long)> self) -> eSlot1LL"""
        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):
    """Proxy of C++ eSignal1<(void,long long)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1LL self, eSlot1LL slot)"""
        return _enigma.eSignal1LL_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,long long)> self) -> eSignal1LL"""
        _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):
    """Proxy of C++ eSlot1<(p.q(const).char,p.q(const).char)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1CStrRCStr self, char const * arg0) -> char const *"""
        return _enigma.eSlot1CStrRCStr_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(p.q(const).char,p.q(const).char)> self) -> eSlot1CStrRCStr"""
        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):
    """Proxy of C++ eSignal1<(p.q(const).char,p.q(const).char)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1CStrRCStr self, eSlot1CStrRCStr slot)"""
        return _enigma.eSignal1CStrRCStr_connect2(self, slot)


    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):
        """__init__(eSignal1<(p.q(const).char,p.q(const).char)> self) -> eSignal1CStrRCStr"""
        _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):
    """Proxy of C++ eSlot1<(void,p.iDVBFrontend)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1iDvbFrontendPtr self, iDVBFrontend * arg0)"""
        return _enigma.eSlot1iDvbFrontendPtr_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,p.iDVBFrontend)> self) -> eSlot1iDvbFrontendPtr"""
        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):
    """Proxy of C++ eSignal1<(void,p.iDVBFrontend)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1iDvbFrontendPtr self, eSlot1iDvbFrontendPtr slot)"""
        return _enigma.eSignal1iDvbFrontendPtr_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,p.iDVBFrontend)> self) -> eSignal1iDvbFrontendPtr"""
        _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):
    """Proxy of C++ eSlot3<(int,int,int,int)> class."""

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

    def cb_func(self, arg0, arg1, arg2):
        """cb_func(eSlot3IIIRetI self, int arg0, int arg1, int arg2) -> int"""
        return _enigma.eSlot3IIIRetI_cb_func(self, arg0, arg1, arg2)


    def __init__(self):
        """__init__(eSlot3<(int,int,int,int)> self) -> eSlot3IIIRetI"""
        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):
    """Proxy of C++ eSignal3<(int,int,int,int)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal3IIIRetI self, eSlot3IIIRetI slot)"""
        return _enigma.eSignal3IIIRetI_connect2(self, slot)


    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):
        """__init__(eSignal3<(int,int,int,int)> self) -> eSignal3IIIRetI"""
        _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):
    """Proxy of C++ eSlot2<(void,r.ePtr<(iRecordableService)>,int)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2IRecordableServicePtrInt self, iRecordableServicePtr arg0, int arg1)"""
        return _enigma.eSlot2IRecordableServicePtrInt_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,r.ePtr<(iRecordableService)>,int)> self) -> eSlot2IRecordableServicePtrInt"""
        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):
    """Proxy of C++ eSignal2<(void,r.ePtr<(iRecordableService)>,int)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2IRecordableServicePtrInt self, eSlot2IRecordableServicePtrInt slot)"""
        return _enigma.eSignal2IRecordableServicePtrInt_connect2(self, slot)


    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):
        """__init__(eSignal2<(void,r.ePtr<(iRecordableService)>,int)> self) -> eSignal2IRecordableServicePtrInt"""
        _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 eSlot2IntInt(eSlot):
    """Proxy of C++ eSlot2<(void,int,int)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2IntInt self, int arg0, int arg1)"""
        return _enigma.eSlot2IntInt_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,int,int)> self) -> eSlot2IntInt"""
        if self.__class__ == eSlot2IntInt:
            _self = None
        else:
            _self = self
        _enigma.eSlot2IntInt_swiginit(self, _enigma.new_eSlot2IntInt(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2IntInt
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2IntInt(self)
        return weakref_proxy(self)
eSlot2IntInt.cb_func = new_instancemethod(_enigma.eSlot2IntInt_cb_func, None, eSlot2IntInt)
eSlot2IntInt_swigregister = _enigma.eSlot2IntInt_swigregister
eSlot2IntInt_swigregister(eSlot2IntInt)

class eSignal2IntInt(object):
    """Proxy of C++ eSignal2<(void,int,int)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2IntInt self, eSlot2IntInt slot)"""
        return _enigma.eSignal2IntInt_connect2(self, slot)


    def connect(self, func):
        class ePythonSlot2IntInt(eSlot2IntInt):
            def __init__(self, func):
                eSlot2IntInt.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2IntInt(WeakMethodReference(func))
        self.connect2(slot)
        return slot

    def __init__(self):
        """__init__(eSignal2<(void,int,int)> self) -> eSignal2IntInt"""
        _enigma.eSignal2IntInt_swiginit(self, _enigma.new_eSignal2IntInt())
    __swig_destroy__ = _enigma.delete_eSignal2IntInt
eSignal2IntInt.connect2 = new_instancemethod(_enigma.eSignal2IntInt_connect2, None, eSignal2IntInt)
eSignal2IntInt_swigregister = _enigma.eSignal2IntInt_swigregister
eSignal2IntInt_swigregister(eSignal2IntInt)

class eSlot2IntIntList(eSlot):
    """Proxy of C++ eSlot2<(void,int,std::list<(int)>)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2IntIntList self, int arg0, IntList arg1)"""
        return _enigma.eSlot2IntIntList_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,int,std::list<(int)>)> self) -> eSlot2IntIntList"""
        if self.__class__ == eSlot2IntIntList:
            _self = None
        else:
            _self = self
        _enigma.eSlot2IntIntList_swiginit(self, _enigma.new_eSlot2IntIntList(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2IntIntList
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2IntIntList(self)
        return weakref_proxy(self)
eSlot2IntIntList.cb_func = new_instancemethod(_enigma.eSlot2IntIntList_cb_func, None, eSlot2IntIntList)
eSlot2IntIntList_swigregister = _enigma.eSlot2IntIntList_swigregister
eSlot2IntIntList_swigregister(eSlot2IntIntList)

class eSignal2IntIntList(object):
    """Proxy of C++ eSignal2<(void,int,std::list<(int)>)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2IntIntList self, eSlot2IntIntList slot)"""
        return _enigma.eSignal2IntIntList_connect2(self, slot)


    def connect(self, func):
        class ePythonSlot2IntIntList(eSlot2IntIntList):
            def __init__(self, func):
                eSlot2IntIntList.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2IntIntList(WeakMethodReference(func))
        self.connect2(slot)
        return slot

    def __init__(self):
        """__init__(eSignal2<(void,int,std::list<(int)>)> self) -> eSignal2IntIntList"""
        _enigma.eSignal2IntIntList_swiginit(self, _enigma.new_eSignal2IntIntList())
    __swig_destroy__ = _enigma.delete_eSignal2IntIntList
eSignal2IntIntList.connect2 = new_instancemethod(_enigma.eSignal2IntIntList_connect2, None, eSignal2IntIntList)
eSignal2IntIntList_swigregister = _enigma.eSignal2IntIntList_swigregister
eSignal2IntIntList_swigregister(eSignal2IntIntList)

class eSlot3IntIntIntList(eSlot):
    """Proxy of C++ eSlot3<(void,int,int,std::list<(int)>)> class."""

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

    def cb_func(self, arg0, arg1, arg2):
        """cb_func(eSlot3IntIntIntList self, int arg0, int arg1, IntList arg2)"""
        return _enigma.eSlot3IntIntIntList_cb_func(self, arg0, arg1, arg2)


    def __init__(self):
        """__init__(eSlot3<(void,int,int,std::list<(int)>)> self) -> eSlot3IntIntIntList"""
        if self.__class__ == eSlot3IntIntIntList:
            _self = None
        else:
            _self = self
        _enigma.eSlot3IntIntIntList_swiginit(self, _enigma.new_eSlot3IntIntIntList(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot3IntIntIntList
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot3IntIntIntList(self)
        return weakref_proxy(self)
eSlot3IntIntIntList.cb_func = new_instancemethod(_enigma.eSlot3IntIntIntList_cb_func, None, eSlot3IntIntIntList)
eSlot3IntIntIntList_swigregister = _enigma.eSlot3IntIntIntList_swigregister
eSlot3IntIntIntList_swigregister(eSlot3IntIntIntList)

class eSignal3IntIntIntList(object):
    """Proxy of C++ eSignal3<(void,int,int,std::list<(int)>)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal3IntIntIntList self, eSlot3IntIntIntList slot)"""
        return _enigma.eSignal3IntIntIntList_connect2(self, slot)


    def connect(self, func):
        class ePythonSlot3IntIntIntList(eSlot3IntIntIntList):
            def __init__(self, func):
                eSlot3IntIntIntList.__init__(self)
                self.cb_func=func
        slot = ePythonSlot3IntIntIntList(WeakMethodReference(func))
        self.connect2(slot)
        return slot

    def __init__(self):
        """__init__(eSignal3<(void,int,int,std::list<(int)>)> self) -> eSignal3IntIntIntList"""
        _enigma.eSignal3IntIntIntList_swiginit(self, _enigma.new_eSignal3IntIntIntList())
    __swig_destroy__ = _enigma.delete_eSignal3IntIntIntList
eSignal3IntIntIntList.connect2 = new_instancemethod(_enigma.eSignal3IntIntIntList_connect2, None, eSignal3IntIntIntList)
eSignal3IntIntIntList_swigregister = _enigma.eSignal3IntIntIntList_swigregister
eSignal3IntIntIntList_swigregister(eSignal3IntIntIntList)

class eSlot1StrMap(eSlot):
    """Proxy of C++ eSlot1<(void,stringMap)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1StrMap self, StringMap arg0)"""
        return _enigma.eSlot1StrMap_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,stringMap)> self) -> eSlot1StrMap"""
        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):
    """Proxy of C++ eSignal1<(void,stringMap)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1StrMap self, eSlot1StrMap slot)"""
        return _enigma.eSignal1StrMap_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,stringMap)> self) -> eSignal1StrMap"""
        _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):
    """Proxy of C++ eSlot2<(void,stringMap,bool)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2StrMapBool self, StringMap arg0, bool arg1)"""
        return _enigma.eSlot2StrMapBool_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,stringMap,bool)> self) -> eSlot2StrMapBool"""
        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):
    """Proxy of C++ eSignal2<(void,stringMap,bool)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2StrMapBool self, eSlot2StrMapBool slot)"""
        return _enigma.eSignal2StrMapBool_connect2(self, slot)


    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):
        """__init__(eSignal2<(void,stringMap,bool)> self) -> eSignal2StrMapBool"""
        _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):
    """Proxy of C++ eSlot2<(void,stringMap,stringSet)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2StrMapStrSet self, StringMap arg0, StringSet arg1)"""
        return _enigma.eSlot2StrMapStrSet_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,stringMap,stringSet)> self) -> eSlot2StrMapStrSet"""
        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):
    """Proxy of C++ eSignal2<(void,stringMap,stringSet)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2StrMapStrSet self, eSlot2StrMapStrSet slot)"""
        return _enigma.eSignal2StrMapStrSet_connect2(self, slot)


    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):
        """__init__(eSignal2<(void,stringMap,stringSet)> self) -> eSignal2StrMapStrSet"""
        _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):
    """Proxy of C++ eSlot2<(void,stringMap,stringMapVector)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2StrMapStrMapVector self, StringMap arg0, StringMapVector arg1)"""
        return _enigma.eSlot2StrMapStrMapVector_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,stringMap,stringMapVector)> self) -> eSlot2StrMapStrMapVector"""
        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):
    """Proxy of C++ eSignal2<(void,stringMap,stringMapVector)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2StrMapStrMapVector self, eSlot2StrMapStrMapVector slot)"""
        return _enigma.eSignal2StrMapStrMapVector_connect2(self, slot)


    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):
        """__init__(eSignal2<(void,stringMap,stringMapVector)> self) -> eSignal2StrMapStrMapVector"""
        _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):
    """Proxy of C++ eSlot3<(void,stringMap,long long,long long)> class."""

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

    def cb_func(self, arg0, arg1, arg2):
        """cb_func(eSlot3StrMapLLLL self, StringMap arg0, long long arg1, long long arg2)"""
        return _enigma.eSlot3StrMapLLLL_cb_func(self, arg0, arg1, arg2)


    def __init__(self):
        """__init__(eSlot3<(void,stringMap,long long,long long)> self) -> eSlot3StrMapLLLL"""
        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):
    """Proxy of C++ eSignal3<(void,stringMap,long long,long long)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal3StrMapLLLL self, eSlot3StrMapLLLL slot)"""
        return _enigma.eSignal3StrMapLLLL_connect2(self, slot)


    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):
        """__init__(eSignal3<(void,stringMap,long long,long long)> self) -> eSignal3StrMapLLLL"""
        _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):
    """Proxy of C++ eSlot3<(void,stringMap,stringMapVector,stringList)> class."""

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

    def cb_func(self, arg0, arg1, arg2):
        """cb_func(eSlot3StrMapStrMapVectorStrList self, StringMap arg0, StringMapVector arg1, StringList arg2)"""
        return _enigma.eSlot3StrMapStrMapVectorStrList_cb_func(self, arg0, arg1, arg2)


    def __init__(self):
        """__init__(eSlot3<(void,stringMap,stringMapVector,stringList)> self) -> eSlot3StrMapStrMapVectorStrList"""
        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):
    """Proxy of C++ eSignal3<(void,stringMap,stringMapVector,stringList)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal3StrMapStrMapVectorStrList self, eSlot3StrMapStrMapVectorStrList slot)"""
        return _enigma.eSignal3StrMapStrMapVectorStrList_connect2(self, slot)


    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):
        """__init__(eSignal3<(void,stringMap,stringMapVector,stringList)> self) -> eSignal3StrMapStrMapVectorStrList"""
        _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):
    """Proxy of C++ eSlot2<(void,int,boost::any)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2IntAny self, int arg0, boost::any arg1)"""
        return _enigma.eSlot2IntAny_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,int,boost::any)> self) -> eSlot2IntAny"""
        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):
    """Proxy of C++ eSignal2<(void,int,boost::any)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2IntAny self, eSlot2IntAny slot)"""
        return _enigma.eSignal2IntAny_connect2(self, slot)


    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):
        """__init__(eSignal2<(void,int,boost::any)> self) -> eSignal2IntAny"""
        _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):
    """Proxy of C++ eSlot4<(void,std::string,uint64_t,uint64_t,uint64_t)> class."""

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

    def cb_func(self, arg0, arg1, arg2, arg3):
        """cb_func(eSlot4StrUInt64UInt64UInt64 self, std::string arg0, unsigned long arg1, unsigned long arg2, unsigned long arg3)"""
        return _enigma.eSlot4StrUInt64UInt64UInt64_cb_func(self, arg0, arg1, arg2, arg3)


    def __init__(self):
        """__init__(eSlot4<(void,std::string,uint64_t,uint64_t,uint64_t)> self) -> eSlot4StrUInt64UInt64UInt64"""
        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):
    """Proxy of C++ eSignal4<(void,std::string,uint64_t,uint64_t,uint64_t)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal4StrUInt64UInt64UInt64 self, eSlot4StrUInt64UInt64UInt64 slot)"""
        return _enigma.eSignal4StrUInt64UInt64UInt64_connect2(self, slot)


    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):
        """__init__(eSignal4<(void,std::string,uint64_t,uint64_t,uint64_t)> self) -> eSignal4StrUInt64UInt64UInt64"""
        _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):
    """Proxy of C++ eSlot4<(void,uint64_t,uint64_t,uint64_t,intList)> class."""

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

    def cb_func(self, arg0, arg1, arg2, arg3):
        """cb_func(eSlot4UInt64UInt64UInt64IntList self, unsigned long arg0, unsigned long arg1, unsigned long arg2, IntList arg3)"""
        return _enigma.eSlot4UInt64UInt64UInt64IntList_cb_func(self, arg0, arg1, arg2, arg3)


    def __init__(self):
        """__init__(eSlot4<(void,uint64_t,uint64_t,uint64_t,intList)> self) -> eSlot4UInt64UInt64UInt64IntList"""
        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):
    """Proxy of C++ eSignal4<(void,uint64_t,uint64_t,uint64_t,intList)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal4UInt64UInt64UInt64IntList self, eSlot4UInt64UInt64UInt64IntList slot)"""
        return _enigma.eSignal4UInt64UInt64UInt64IntList_connect2(self, slot)


    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):
        """__init__(eSignal4<(void,uint64_t,uint64_t,uint64_t,intList)> self) -> eSignal4UInt64UInt64UInt64IntList"""
        _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):
    """Proxy of C++ eSlot5<(void,std::string,uint64_t,uint64_t,uint64_t,intList)> class."""

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

    def cb_func(self, arg0, arg1, arg2, arg3, arg4):
        """cb_func(eSlot5CStrUInt64UInt64UInt64Int self, std::string arg0, unsigned long arg1, unsigned long arg2, unsigned long arg3, IntList arg4)"""
        return _enigma.eSlot5CStrUInt64UInt64UInt64Int_cb_func(self, arg0, arg1, arg2, arg3, arg4)


    def __init__(self):
        """__init__(eSlot5<(void,std::string,uint64_t,uint64_t,uint64_t,intList)> self) -> eSlot5CStrUInt64UInt64UInt64Int"""
        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):
    """Proxy of C++ eSignal5<(void,std::string,uint64_t,uint64_t,uint64_t,intList)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal5CStrUInt64UInt64UInt64Int self, eSlot5CStrUInt64UInt64UInt64Int slot)"""
        return _enigma.eSignal5CStrUInt64UInt64UInt64Int_connect2(self, slot)


    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):
        """__init__(eSignal5<(void,std::string,uint64_t,uint64_t,uint64_t,intList)> self) -> eSignal5CStrUInt64UInt64UInt64Int"""
        _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):
    """Proxy of C++ eSlot1<(void,bool)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1Bool self, bool arg0)"""
        return _enigma.eSlot1Bool_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,bool)> self) -> eSlot1Bool"""
        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):
    """Proxy of C++ eSignal1<(void,bool)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1Bool self, eSlot1Bool slot)"""
        return _enigma.eSignal1Bool_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,bool)> self) -> eSignal1Bool"""
        _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):
    """Proxy of C++ eSlot1<(void,std::string)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1Str self, std::string arg0)"""
        return _enigma.eSlot1Str_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,std::string)> self) -> eSlot1Str"""
        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):
    """Proxy of C++ eSignal1<(void,std::string)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1Str self, eSlot1Str slot)"""
        return _enigma.eSignal1Str_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,std::string)> self) -> eSignal1Str"""
        _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):
    """Proxy of C++ eSlot1<(void,ePtr<(eNetworkService)>)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1NetworkService self, eNetworkServicePtr arg0)"""
        return _enigma.eSlot1NetworkService_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,ePtr<(eNetworkService)>)> self) -> eSlot1NetworkService"""
        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):
    """Proxy of C++ eSignal1<(void,ePtr<(eNetworkService)>)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1NetworkService self, eSlot1NetworkService slot)"""
        return _enigma.eSignal1NetworkService_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,ePtr<(eNetworkService)>)> self) -> eSignal1NetworkService"""
        _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):
    """Proxy of C++ eSlot1<(void,stringList)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1StringList self, StringList arg0)"""
        return _enigma.eSlot1StringList_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,stringList)> self) -> eSlot1StringList"""
        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):
    """Proxy of C++ eSignal1<(void,stringList)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1StringList self, eSlot1StringList slot)"""
        return _enigma.eSignal1StringList_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,stringList)> self) -> eSignal1StringList"""
        _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):
    """Proxy of C++ eSlot2<(void,std::string,std::map<(std::string,boost::any)>)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2StrMapStrAny self, std::string arg0, PseudoDict arg1)"""
        return _enigma.eSlot2StrMapStrAny_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,std::string,std::map<(std::string,boost::any)>)> self) -> eSlot2StrMapStrAny"""
        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):
    """Proxy of C++ eSignal2<(void,std::string,std::map<(std::string,boost::any)>)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2StrMapStrAny self, eSlot2StrMapStrAny slot)"""
        return _enigma.eSignal2StrMapStrAny_connect2(self, slot)


    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):
        """__init__(eSignal2<(void,std::string,std::map<(std::string,boost::any)>)> self) -> eSignal2StrMapStrAny"""
        _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):
    """Proxy of C++ eSlot2<(void,std::string,std::string)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2StrStr self, std::string arg0, std::string arg1)"""
        return _enigma.eSlot2StrStr_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,std::string,std::string)> self) -> eSlot2StrStr"""
        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):
    """Proxy of C++ eSignal2<(void,std::string,std::string)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2StrStr self, eSlot2StrStr slot)"""
        return _enigma.eSignal2StrStr_connect2(self, slot)


    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):
        """__init__(eSignal2<(void,std::string,std::string)> self) -> eSignal2StrStr"""
        _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):
    """Proxy of C++ eSlot1<(void,uint)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1UInt self, uint arg0)"""
        return _enigma.eSlot1UInt_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,uint)> self) -> eSlot1UInt"""
        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):
    """Proxy of C++ eSignal1<(void,uint)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1UInt self, eSlot1UInt slot)"""
        return _enigma.eSignal1UInt_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,uint)> self) -> eSignal1UInt"""
        _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):
    """Proxy of C++ eSlot1<(void,std::map<(std::string,boost::any)>)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1MapStrAny self, PseudoDict arg0)"""
        return _enigma.eSlot1MapStrAny_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,std::map<(std::string,boost::any)>)> self) -> eSlot1MapStrAny"""
        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):
    """Proxy of C++ eSignal1<(void,std::map<(std::string,boost::any)>)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1MapStrAny self, eSlot1MapStrAny slot)"""
        return _enigma.eSignal1MapStrAny_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,std::map<(std::string,boost::any)>)> self) -> eSignal1MapStrAny"""
        _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):
    """Proxy of C++ eSlot1<(void,uint32_t)> class."""

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

    def cb_func(self, arg0):
        """cb_func(eSlot1UInt32 self, unsigned int arg0)"""
        return _enigma.eSlot1UInt32_cb_func(self, arg0)


    def __init__(self):
        """__init__(eSlot1<(void,uint32_t)> self) -> eSlot1UInt32"""
        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):
    """Proxy of C++ eSignal1<(void,uint32_t)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal1UInt32 self, eSlot1UInt32 slot)"""
        return _enigma.eSignal1UInt32_connect2(self, slot)


    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):
        """__init__(eSignal1<(void,uint32_t)> self) -> eSignal1UInt32"""
        _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 eSlot2IntString(eSlot):
    """Proxy of C++ eSlot2<(void,int,std::string)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2IntString self, int arg0, std::string arg1)"""
        return _enigma.eSlot2IntString_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,int,std::string)> self) -> eSlot2IntString"""
        if self.__class__ == eSlot2IntString:
            _self = None
        else:
            _self = self
        _enigma.eSlot2IntString_swiginit(self, _enigma.new_eSlot2IntString(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2IntString
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2IntString(self)
        return weakref_proxy(self)
eSlot2IntString.cb_func = new_instancemethod(_enigma.eSlot2IntString_cb_func, None, eSlot2IntString)
eSlot2IntString_swigregister = _enigma.eSlot2IntString_swigregister
eSlot2IntString_swigregister(eSlot2IntString)

class eSignal2IntString(object):
    """Proxy of C++ eSignal2<(void,int,std::string)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2IntString self, eSlot2IntString slot)"""
        return _enigma.eSignal2IntString_connect2(self, slot)


    def connect(self, func):
        class ePythonSlot2IntString(eSlot2IntString):
            def __init__(self, func):
                eSlot2IntString.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2IntString(WeakMethodReference(func))
        self.connect2(slot)
        return slot

    def __init__(self):
        """__init__(eSignal2<(void,int,std::string)> self) -> eSignal2IntString"""
        _enigma.eSignal2IntString_swiginit(self, _enigma.new_eSignal2IntString())
    __swig_destroy__ = _enigma.delete_eSignal2IntString
eSignal2IntString.connect2 = new_instancemethod(_enigma.eSignal2IntString_connect2, None, eSignal2IntString)
eSignal2IntString_swigregister = _enigma.eSignal2IntString_swigregister
eSignal2IntString_swigregister(eSignal2IntString)

class eSlot2FileWatchEvent(eSlot):
    """Proxy of C++ eSlot2<(void,p.eFileWatch,eFileEvent)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2FileWatchEvent self, eFileWatch arg0, eFileEvent arg1)"""
        return _enigma.eSlot2FileWatchEvent_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,p.eFileWatch,eFileEvent)> self) -> eSlot2FileWatchEvent"""
        if self.__class__ == eSlot2FileWatchEvent:
            _self = None
        else:
            _self = self
        _enigma.eSlot2FileWatchEvent_swiginit(self, _enigma.new_eSlot2FileWatchEvent(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2FileWatchEvent
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2FileWatchEvent(self)
        return weakref_proxy(self)
eSlot2FileWatchEvent.cb_func = new_instancemethod(_enigma.eSlot2FileWatchEvent_cb_func, None, eSlot2FileWatchEvent)
eSlot2FileWatchEvent_swigregister = _enigma.eSlot2FileWatchEvent_swigregister
eSlot2FileWatchEvent_swigregister(eSlot2FileWatchEvent)

class eSignal2FileWatchEvent(object):
    """Proxy of C++ eSignal2<(void,p.eFileWatch,eFileEvent)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2FileWatchEvent self, eSlot2FileWatchEvent slot)"""
        return _enigma.eSignal2FileWatchEvent_connect2(self, slot)


    def connect(self, func):
        class ePythonSlot2FileWatchEvent(eSlot2FileWatchEvent):
            def __init__(self, func):
                eSlot2FileWatchEvent.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2FileWatchEvent(WeakMethodReference(func))
        self.connect2(slot)
        return slot

    def __init__(self):
        """__init__(eSignal2<(void,p.eFileWatch,eFileEvent)> self) -> eSignal2FileWatchEvent"""
        _enigma.eSignal2FileWatchEvent_swiginit(self, _enigma.new_eSignal2FileWatchEvent())
    __swig_destroy__ = _enigma.delete_eSignal2FileWatchEvent
eSignal2FileWatchEvent.connect2 = new_instancemethod(_enigma.eSignal2FileWatchEvent_connect2, None, eSignal2FileWatchEvent)
eSignal2FileWatchEvent_swigregister = _enigma.eSignal2FileWatchEvent_swigregister
eSignal2FileWatchEvent_swigregister(eSignal2FileWatchEvent)

class eSlot2ConstStrBool(eSlot):
    """Proxy of C++ eSlot2<(void,q(const).std::string,bool)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2ConstStrBool self, std::string const arg0, bool arg1)"""
        return _enigma.eSlot2ConstStrBool_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,q(const).std::string,bool)> self) -> eSlot2ConstStrBool"""
        if self.__class__ == eSlot2ConstStrBool:
            _self = None
        else:
            _self = self
        _enigma.eSlot2ConstStrBool_swiginit(self, _enigma.new_eSlot2ConstStrBool(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2ConstStrBool
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2ConstStrBool(self)
        return weakref_proxy(self)
eSlot2ConstStrBool.cb_func = new_instancemethod(_enigma.eSlot2ConstStrBool_cb_func, None, eSlot2ConstStrBool)
eSlot2ConstStrBool_swigregister = _enigma.eSlot2ConstStrBool_swigregister
eSlot2ConstStrBool_swigregister(eSlot2ConstStrBool)

class eSignal2ConstStrBool(object):
    """Proxy of C++ eSignal2<(void,q(const).std::string,bool)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2ConstStrBool self, eSlot2ConstStrBool slot)"""
        return _enigma.eSignal2ConstStrBool_connect2(self, slot)


    def connect(self, func):
        class ePythonSlot2ConstStrBool(eSlot2ConstStrBool):
            def __init__(self, func):
                eSlot2ConstStrBool.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2ConstStrBool(WeakMethodReference(func))
        self.connect2(slot)
        return slot

    def __init__(self):
        """__init__(eSignal2<(void,q(const).std::string,bool)> self) -> eSignal2ConstStrBool"""
        _enigma.eSignal2ConstStrBool_swiginit(self, _enigma.new_eSignal2ConstStrBool())
    __swig_destroy__ = _enigma.delete_eSignal2ConstStrBool
eSignal2ConstStrBool.connect2 = new_instancemethod(_enigma.eSignal2ConstStrBool_connect2, None, eSignal2ConstStrBool)
eSignal2ConstStrBool_swigregister = _enigma.eSignal2ConstStrBool_swigregister
eSignal2ConstStrBool_swigregister(eSignal2ConstStrBool)

class eSlot2ConstStrInt(eSlot):
    """Proxy of C++ eSlot2<(void,q(const).std::string,int)> class."""

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

    def cb_func(self, arg0, arg1):
        """cb_func(eSlot2ConstStrInt self, std::string const arg0, int arg1)"""
        return _enigma.eSlot2ConstStrInt_cb_func(self, arg0, arg1)


    def __init__(self):
        """__init__(eSlot2<(void,q(const).std::string,int)> self) -> eSlot2ConstStrInt"""
        if self.__class__ == eSlot2ConstStrInt:
            _self = None
        else:
            _self = self
        _enigma.eSlot2ConstStrInt_swiginit(self, _enigma.new_eSlot2ConstStrInt(_self, ))
    __swig_destroy__ = _enigma.delete_eSlot2ConstStrInt
    def __disown__(self):
        self.this.disown()
        _enigma.disown_eSlot2ConstStrInt(self)
        return weakref_proxy(self)
eSlot2ConstStrInt.cb_func = new_instancemethod(_enigma.eSlot2ConstStrInt_cb_func, None, eSlot2ConstStrInt)
eSlot2ConstStrInt_swigregister = _enigma.eSlot2ConstStrInt_swigregister
eSlot2ConstStrInt_swigregister(eSlot2ConstStrInt)

class eSignal2ConstStrInt(object):
    """Proxy of C++ eSignal2<(void,q(const).std::string,int)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal2ConstStrInt self, eSlot2ConstStrInt slot)"""
        return _enigma.eSignal2ConstStrInt_connect2(self, slot)


    def connect(self, func):
        class ePythonSlot2ConstStrInt(eSlot2ConstStrInt):
            def __init__(self, func):
                eSlot2ConstStrInt.__init__(self)
                self.cb_func=func
        slot = ePythonSlot2ConstStrInt(WeakMethodReference(func))
        self.connect2(slot)
        return slot

    def __init__(self):
        """__init__(eSignal2<(void,q(const).std::string,int)> self) -> eSignal2ConstStrInt"""
        _enigma.eSignal2ConstStrInt_swiginit(self, _enigma.new_eSignal2ConstStrInt())
    __swig_destroy__ = _enigma.delete_eSignal2ConstStrInt
eSignal2ConstStrInt.connect2 = new_instancemethod(_enigma.eSignal2ConstStrInt_connect2, None, eSignal2ConstStrInt)
eSignal2ConstStrInt_swigregister = _enigma.eSignal2ConstStrInt_swigregister
eSignal2ConstStrInt_swigregister(eSignal2ConstStrInt)

class eSlot4UIntUIntUIntUInt(eSlot):
    """Proxy of C++ eSlot4<(void,unsigned int,unsigned int,unsigned int,unsigned int)> class."""

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

    def cb_func(self, arg0, arg1, arg2, arg3):
        """cb_func(eSlot4UIntUIntUIntUInt self, unsigned int arg0, unsigned int arg1, unsigned int arg2, unsigned int arg3)"""
        return _enigma.eSlot4UIntUIntUIntUInt_cb_func(self, arg0, arg1, arg2, arg3)


    def __init__(self):
        """__init__(eSlot4<(void,unsigned int,unsigned int,unsigned int,unsigned int)> self) -> eSlot4UIntUIntUIntUInt"""
        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):
    """Proxy of C++ eSignal4<(void,unsigned int,unsigned int,unsigned int,unsigned int)> class."""

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

    def connect2(self, slot):
        """connect2(eSignal4UIntUIntUIntUInt self, eSlot4UIntUIntUIntUInt slot)"""
        return _enigma.eSignal4UIntUIntUIntUInt_connect2(self, slot)


    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):
        """__init__(eSignal4<(void,unsigned int,unsigned int,unsigned int,unsigned int)> self) -> eSignal4UIntUIntUIntUInt"""
        _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(bouquet_ref, ignore, simulate=False):
    """
    getBestPlayableServiceReference(eServiceReference bouquet_ref, eServiceReference ignore, bool simulate=False) -> PyObject
    getBestPlayableServiceReference(eServiceReference bouquet_ref, eServiceReference ignore) -> PyObject *
    """
    return _enigma.getBestPlayableServiceReference(bouquet_ref, ignore, simulate)

def setTunerTypePriorityOrder(arg1):
    """setTunerTypePriorityOrder(int arg1)"""
    return _enigma.setTunerTypePriorityOrder(arg1)

def getExitCode():
    """getExitCode() -> int"""
    return _enigma.getExitCode()

def addFont(filename, alias, scale_factor, is_replacement):
    """addFont(char const * filename, char const * alias, int scale_factor, int is_replacement)"""
    return _enigma.addFont(filename, alias, scale_factor, is_replacement)

def getPrevAsciiCode():
    """getPrevAsciiCode() -> int"""
    return _enigma.getPrevAsciiCode()

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

def quitMainloop(exit_code):
    """quitMainloop(int exit_code)"""
    return _enigma.quitMainloop(exit_code)

def getEnigmaVersionString():
    """getEnigmaVersionString() -> char const *"""
    return _enigma.getEnigmaVersionString()

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


