4.5.0r6
[enigma2.git] / usr / lib / enigma2 / python / enigma.py
1 # This file was automatically generated by SWIG (http://www.swig.org).
2 # Version 3.0.12
3 #
4 # Do not make changes to this file unless you know what you are doing--modify
5 # the SWIG interface file instead.
6
7 from sys import version_info as _swig_python_version_info
8 if _swig_python_version_info >= (3, 0, 0):
9     new_instancemethod = lambda func, inst, cls: _enigma.SWIG_PyInstanceMethod_New(func)
10 else:
11     from new import instancemethod as new_instancemethod
12 if _swig_python_version_info >= (2, 7, 0):
13     def swig_import_helper():
14         import importlib
15         pkg = __name__.rpartition('.')[0]
16         mname = '.'.join((pkg, '_enigma')).lstrip('.')
17         try:
18             return importlib.import_module(mname)
19         except ImportError:
20             return importlib.import_module('_enigma')
21     _enigma = swig_import_helper()
22     del swig_import_helper
23 elif _swig_python_version_info >= (2, 6, 0):
24     def swig_import_helper():
25         from os.path import dirname
26         import imp
27         fp = None
28         try:
29             fp, pathname, description = imp.find_module('_enigma', [dirname(__file__)])
30         except ImportError:
31             import _enigma
32             return _enigma
33         try:
34             _mod = imp.load_module('_enigma', fp, pathname, description)
35         finally:
36             if fp is not None:
37                 fp.close()
38         return _mod
39     _enigma = swig_import_helper()
40     del swig_import_helper
41 else:
42     import _enigma
43 del _swig_python_version_info
44
45 try:
46     _swig_property = property
47 except NameError:
48     pass  # Python < 2.2 doesn't have 'property'.
49
50 try:
51     import builtins as __builtin__
52 except ImportError:
53     import __builtin__
54
55 def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
56     if (name == "thisown"):
57         return self.this.own(value)
58     if (name == "this"):
59         if type(value).__name__ == 'SwigPyObject':
60             self.__dict__[name] = value
61             return
62     method = class_type.__swig_setmethods__.get(name, None)
63     if method:
64         return method(self, value)
65     if (not static):
66         object.__setattr__(self, name, value)
67     else:
68         raise AttributeError("You cannot add attributes to %s" % self)
69
70
71 def _swig_setattr(self, class_type, name, value):
72     return _swig_setattr_nondynamic(self, class_type, name, value, 0)
73
74
75 def _swig_getattr(self, class_type, name):
76     if (name == "thisown"):
77         return self.this.own()
78     method = class_type.__swig_getmethods__.get(name, None)
79     if method:
80         return method(self)
81     raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
82
83
84 def _swig_repr(self):
85     try:
86         strthis = "proxy of " + self.this.__repr__()
87     except __builtin__.Exception:
88         strthis = ""
89     return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
90
91
92 def _swig_setattr_nondynamic_method(set):
93     def set_attr(self, name, value):
94         if (name == "thisown"):
95             return self.this.own(value)
96         if hasattr(self, name) or (name == "this"):
97             set(self, name, value)
98         else:
99             raise AttributeError("You cannot add attributes to %s" % self)
100     return set_attr
101
102
103 try:
104     import weakref
105     weakref_proxy = weakref.proxy
106 except __builtin__.Exception:
107     weakref_proxy = lambda x: x
108
109
110 __ENIGMA_PYTHON_I_INSIDE__ = _enigma.__ENIGMA_PYTHON_I_INSIDE__
111 COMPOSITION_MODE_BUFFERED = _enigma.COMPOSITION_MODE_BUFFERED
112 DEBUG = _enigma.DEBUG
113 DISPLAY_FBDEV = _enigma.DISPLAY_FBDEV
114 ENABLE_ALSA_AUDIO = _enigma.ENABLE_ALSA_AUDIO
115 ENABLE_EWEBVIEW = _enigma.ENABLE_EWEBVIEW
116 ENABLE_SVG = _enigma.ENABLE_SVG
117 HAVE_BOOST = _enigma.HAVE_BOOST
118 HAVE_BOOST_ALGORITHM_STRING_HPP = _enigma.HAVE_BOOST_ALGORITHM_STRING_HPP
119 HAVE_BOOST_FORMAT_HPP = _enigma.HAVE_BOOST_FORMAT_HPP
120 HAVE_CXX14 = _enigma.HAVE_CXX14
121 HAVE_DATE_DATE_H = _enigma.HAVE_DATE_DATE_H
122 HAVE_DLFCN_H = _enigma.HAVE_DLFCN_H
123 HAVE_DRM_DRM_FOURCC_H = _enigma.HAVE_DRM_DRM_FOURCC_H
124 HAVE_EGL_EGLEXT_H = _enigma.HAVE_EGL_EGLEXT_H
125 HAVE_EGL_EGL_H = _enigma.HAVE_EGL_EGL_H
126 HAVE_GLES2_GL2EXT_H = _enigma.HAVE_GLES2_GL2EXT_H
127 HAVE_GLES2_GL2_H = _enigma.HAVE_GLES2_GL2_H
128 HAVE_GLES3_GL31_H = _enigma.HAVE_GLES3_GL31_H
129 HAVE_GLES3_GL32_H = _enigma.HAVE_GLES3_GL32_H
130 HAVE_GLES3_GL3_H = _enigma.HAVE_GLES3_GL3_H
131 HAVE_GST_1 = _enigma.HAVE_GST_1
132 HAVE_GST_STREAM_FLAG_FORCED = _enigma.HAVE_GST_STREAM_FLAG_FORCED
133 HAVE_INTTYPES_H = _enigma.HAVE_INTTYPES_H
134 HAVE_LIBSYSTEMD = _enigma.HAVE_LIBSYSTEMD
135 HAVE_LIBTURBOJPEG = _enigma.HAVE_LIBTURBOJPEG
136 HAVE_LIBUNWIND_H = _enigma.HAVE_LIBUNWIND_H
137 HAVE_MEMORY_H = _enigma.HAVE_MEMORY_H
138 HAVE_PTHREAD = _enigma.HAVE_PTHREAD
139 HAVE_PTHREAD_PRIO_INHERIT = _enigma.HAVE_PTHREAD_PRIO_INHERIT
140 HAVE_PYTHON = _enigma.HAVE_PYTHON
141 HAVE_QT = _enigma.HAVE_QT
142 HAVE_QT_GUI = _enigma.HAVE_QT_GUI
143 HAVE_QT_OPENGL = _enigma.HAVE_QT_OPENGL
144 HAVE_QWEBSETTINGS_WEBSECURITY_ENABLED = _enigma.HAVE_QWEBSETTINGS_WEBSECURITY_ENABLED
145 HAVE_STDINT_H = _enigma.HAVE_STDINT_H
146 HAVE_STDLIB_H = _enigma.HAVE_STDLIB_H
147 HAVE_STRINGS_H = _enigma.HAVE_STRINGS_H
148 HAVE_STRING_H = _enigma.HAVE_STRING_H
149 HAVE_SYS_STAT_H = _enigma.HAVE_SYS_STAT_H
150 HAVE_SYS_TYPES_H = _enigma.HAVE_SYS_TYPES_H
151 HAVE_UNISTD_H = _enigma.HAVE_UNISTD_H
152 HAVE_WEBM_WEBM_PARSER_H = _enigma.HAVE_WEBM_WEBM_PARSER_H
153 LT_OBJDIR = _enigma.LT_OBJDIR
154 PACKAGE_BUGREPORT = _enigma.PACKAGE_BUGREPORT
155 PACKAGE_NAME = _enigma.PACKAGE_NAME
156 PACKAGE_STRING = _enigma.PACKAGE_STRING
157 PACKAGE_TARNAME = _enigma.PACKAGE_TARNAME
158 PACKAGE_URL = _enigma.PACKAGE_URL
159 PACKAGE_VERSION = _enigma.PACKAGE_VERSION
160 STDC_HEADERS = _enigma.STDC_HEADERS
161 _ALL_SOURCE = _enigma._ALL_SOURCE
162 _GNU_SOURCE = _enigma._GNU_SOURCE
163 _POSIX_PTHREAD_SEMANTICS = _enigma._POSIX_PTHREAD_SEMANTICS
164 _TANDEM_SOURCE = _enigma._TANDEM_SOURCE
165 __EXTENSIONS__ = _enigma.__EXTENSIONS__
166 _DARWIN_USE_64_BIT_INODE = _enigma._DARWIN_USE_64_BIT_INODE
167 class SwigPyIterator(object):
168     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
169
170     def __init__(self, *args, **kwargs):
171         raise AttributeError("No constructor defined - class is abstract")
172     __repr__ = _swig_repr
173     __swig_destroy__ = _enigma.delete_SwigPyIterator
174     def __iter__(self):
175         return self
176 SwigPyIterator.value = new_instancemethod(_enigma.SwigPyIterator_value, None, SwigPyIterator)
177 SwigPyIterator.incr = new_instancemethod(_enigma.SwigPyIterator_incr, None, SwigPyIterator)
178 SwigPyIterator.decr = new_instancemethod(_enigma.SwigPyIterator_decr, None, SwigPyIterator)
179 SwigPyIterator.distance = new_instancemethod(_enigma.SwigPyIterator_distance, None, SwigPyIterator)
180 SwigPyIterator.equal = new_instancemethod(_enigma.SwigPyIterator_equal, None, SwigPyIterator)
181 SwigPyIterator.copy = new_instancemethod(_enigma.SwigPyIterator_copy, None, SwigPyIterator)
182 SwigPyIterator.next = new_instancemethod(_enigma.SwigPyIterator_next, None, SwigPyIterator)
183 SwigPyIterator.__next__ = new_instancemethod(_enigma.SwigPyIterator___next__, None, SwigPyIterator)
184 SwigPyIterator.previous = new_instancemethod(_enigma.SwigPyIterator_previous, None, SwigPyIterator)
185 SwigPyIterator.advance = new_instancemethod(_enigma.SwigPyIterator_advance, None, SwigPyIterator)
186 SwigPyIterator.__eq__ = new_instancemethod(_enigma.SwigPyIterator___eq__, None, SwigPyIterator)
187 SwigPyIterator.__ne__ = new_instancemethod(_enigma.SwigPyIterator___ne__, None, SwigPyIterator)
188 SwigPyIterator.__iadd__ = new_instancemethod(_enigma.SwigPyIterator___iadd__, None, SwigPyIterator)
189 SwigPyIterator.__isub__ = new_instancemethod(_enigma.SwigPyIterator___isub__, None, SwigPyIterator)
190 SwigPyIterator.__add__ = new_instancemethod(_enigma.SwigPyIterator___add__, None, SwigPyIterator)
191 SwigPyIterator.__sub__ = new_instancemethod(_enigma.SwigPyIterator___sub__, None, SwigPyIterator)
192 SwigPyIterator_swigregister = _enigma.SwigPyIterator_swigregister
193 SwigPyIterator_swigregister(SwigPyIterator)
194
195 class iObject(object):
196     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
197
198     def __init__(self, *args, **kwargs):
199         raise AttributeError("No constructor defined - class is abstract")
200     __repr__ = _swig_repr
201     __swig_destroy__ = _enigma.delete_iObject
202 iObject_swigregister = _enigma.iObject_swigregister
203 iObject_swigregister(iObject)
204
205 class eMainloop(object):
206     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
207
208     def __init__(self, *args, **kwargs):
209         raise AttributeError("No constructor defined - class is abstract")
210     __repr__ = _swig_repr
211
212     def runLoop(self):
213         """runLoop(eMainloop self) -> int"""
214         return _enigma.eMainloop_runLoop(self)
215
216
217     def isIdle(self):
218         """isIdle(eMainloop self) -> int"""
219         return _enigma.eMainloop_isIdle(self)
220
221
222     def idleCount(self):
223         """idleCount(eMainloop self) -> int"""
224         return _enigma.eMainloop_idleCount(self)
225
226
227     def tid(self):
228         """tid(eMainloop self) -> pid_t"""
229         return _enigma.eMainloop_tid(self)
230
231
232     def argc(self):
233         """argc(eMainloop self) -> int &"""
234         return _enigma.eMainloop_argc(self)
235
236
237     def argv(self):
238         """argv(eMainloop self) -> char **"""
239         return _enigma.eMainloop_argv(self)
240
241 eMainloop.runLoop = new_instancemethod(_enigma.eMainloop_runLoop, None, eMainloop)
242 eMainloop.isIdle = new_instancemethod(_enigma.eMainloop_isIdle, None, eMainloop)
243 eMainloop.idleCount = new_instancemethod(_enigma.eMainloop_idleCount, None, eMainloop)
244 eMainloop.tid = new_instancemethod(_enigma.eMainloop_tid, None, eMainloop)
245 eMainloop.argc = new_instancemethod(_enigma.eMainloop_argc, None, eMainloop)
246 eMainloop.argv = new_instancemethod(_enigma.eMainloop_argv, None, eMainloop)
247 eMainloop_swigregister = _enigma.eMainloop_swigregister
248 eMainloop_swigregister(eMainloop)
249 cvar = _enigma.cvar
250
251 class eSocketNotifier(iObject):
252     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
253     __repr__ = _swig_repr
254     Read = _enigma.eSocketNotifier_Read
255     Write = _enigma.eSocketNotifier_Write
256     Priority = _enigma.eSocketNotifier_Priority
257     Error = _enigma.eSocketNotifier_Error
258     Hungup = _enigma.eSocketNotifier_Hungup
259     __swig_destroy__ = _enigma.delete_eSocketNotifier
260     activated = _swig_property(_enigma.eSocketNotifier_activated_get, _enigma.eSocketNotifier_activated_set)
261
262     def start(self):
263         """start(eSocketNotifier self)"""
264         return _enigma.eSocketNotifier_start(self)
265
266
267     def stop(self):
268         """stop(eSocketNotifier self)"""
269         return _enigma.eSocketNotifier_stop(self)
270
271
272     def isRunning(self):
273         """isRunning(eSocketNotifier self) -> bool"""
274         return _enigma.eSocketNotifier_isRunning(self)
275
276
277     def getFD(self):
278         """getFD(eSocketNotifier self) -> int"""
279         return _enigma.eSocketNotifier_getFD(self)
280
281
282     def getRequested(self):
283         """getRequested(eSocketNotifier self) -> int"""
284         return _enigma.eSocketNotifier_getRequested(self)
285
286
287     def setRequested(self, req):
288         """setRequested(eSocketNotifier self, int req)"""
289         return _enigma.eSocketNotifier_setRequested(self, req)
290
291
292     def getState(self):
293         """getState(eSocketNotifier self) -> int"""
294         return _enigma.eSocketNotifier_getState(self)
295
296
297     def activate(self, what):
298         """activate(eSocketNotifier self, int what)"""
299         return _enigma.eSocketNotifier_activate(self, what)
300
301
302     def getContext(self):
303         """getContext(eSocketNotifier self) -> eMainloop"""
304         return _enigma.eSocketNotifier_getContext(self)
305
306
307     def __init__(self, fd, req, startNow=True):
308         """
309         __init__(eSocketNotifier self, int fd, int req, bool startNow=True) -> eSocketNotifier
310         __init__(eSocketNotifier self, int fd, int req) -> eSocketNotifier
311         """
312         _enigma.eSocketNotifier_swiginit(self, _enigma.new_eSocketNotifier(fd, req, startNow))
313 eSocketNotifier.start = new_instancemethod(_enigma.eSocketNotifier_start, None, eSocketNotifier)
314 eSocketNotifier.stop = new_instancemethod(_enigma.eSocketNotifier_stop, None, eSocketNotifier)
315 eSocketNotifier.isRunning = new_instancemethod(_enigma.eSocketNotifier_isRunning, None, eSocketNotifier)
316 eSocketNotifier.getFD = new_instancemethod(_enigma.eSocketNotifier_getFD, None, eSocketNotifier)
317 eSocketNotifier.getRequested = new_instancemethod(_enigma.eSocketNotifier_getRequested, None, eSocketNotifier)
318 eSocketNotifier.setRequested = new_instancemethod(_enigma.eSocketNotifier_setRequested, None, eSocketNotifier)
319 eSocketNotifier.getState = new_instancemethod(_enigma.eSocketNotifier_getState, None, eSocketNotifier)
320 eSocketNotifier.activate = new_instancemethod(_enigma.eSocketNotifier_activate, None, eSocketNotifier)
321 eSocketNotifier.getContext = new_instancemethod(_enigma.eSocketNotifier_getContext, None, eSocketNotifier)
322 eSocketNotifier_swigregister = _enigma.eSocketNotifier_swigregister
323 eSocketNotifier_swigregister(eSocketNotifier)
324
325 class eTimer(iObject):
326     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
327     __repr__ = _swig_repr
328     __swig_destroy__ = _enigma.delete_eTimer
329     timeout = _swig_property(_enigma.eTimer_timeout_get, _enigma.eTimer_timeout_set)
330
331     def isActive(self):
332         """isActive(eTimer self) -> bool"""
333         return _enigma.eTimer_isActive(self)
334
335
336     def getNextActivation(self):
337         """getNextActivation(eTimer self) -> timespec &"""
338         return _enigma.eTimer_getNextActivation(self)
339
340
341     def getInterval(self):
342         """getInterval(eTimer self) -> int"""
343         return _enigma.eTimer_getInterval(self)
344
345
346     def activate(self):
347         """activate(eTimer self)"""
348         return _enigma.eTimer_activate(self)
349
350
351     def start(self, msec, b=False):
352         """
353         start(eTimer self, int msec, bool b=False)
354         start(eTimer self, int msec)
355         """
356         return _enigma.eTimer_start(self, msec, b)
357
358
359     def stop(self):
360         """stop(eTimer self)"""
361         return _enigma.eTimer_stop(self)
362
363
364     def changeInterval(self, msek):
365         """changeInterval(eTimer self, int msek)"""
366         return _enigma.eTimer_changeInterval(self, msek)
367
368
369     def startLongTimer(self, seconds):
370         """startLongTimer(eTimer self, int seconds)"""
371         return _enigma.eTimer_startLongTimer(self, seconds)
372
373
374     def __init__(self):
375         """__init__(eTimer self) -> eTimer"""
376         _enigma.eTimer_swiginit(self, _enigma.new_eTimer())
377 eTimer.isActive = new_instancemethod(_enigma.eTimer_isActive, None, eTimer)
378 eTimer.getNextActivation = new_instancemethod(_enigma.eTimer_getNextActivation, None, eTimer)
379 eTimer.getInterval = new_instancemethod(_enigma.eTimer_getInterval, None, eTimer)
380 eTimer.activate = new_instancemethod(_enigma.eTimer_activate, None, eTimer)
381 eTimer.start = new_instancemethod(_enigma.eTimer_start, None, eTimer)
382 eTimer.stop = new_instancemethod(_enigma.eTimer_stop, None, eTimer)
383 eTimer.changeInterval = new_instancemethod(_enigma.eTimer_changeInterval, None, eTimer)
384 eTimer.startLongTimer = new_instancemethod(_enigma.eTimer_startLongTimer, None, eTimer)
385 eTimer_swigregister = _enigma.eTimer_swigregister
386 eTimer_swigregister(eTimer)
387
388 class eConsoleAppContainer(iObject):
389     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
390     __repr__ = _swig_repr
391
392     def __init__(self):
393         """__init__(eConsoleAppContainer self) -> eConsoleAppContainer"""
394         _enigma.eConsoleAppContainer_swiginit(self, _enigma.new_eConsoleAppContainer())
395     __swig_destroy__ = _enigma.delete_eConsoleAppContainer
396
397     def setCWD(self, path):
398         """setCWD(eConsoleAppContainer self, char const * path) -> int"""
399         return _enigma.eConsoleAppContainer_setCWD(self, path)
400
401
402     def exec1(self, str):
403         """exec1(eConsoleAppContainer self, char const * str) -> int"""
404         return _enigma.eConsoleAppContainer_exec1(self, str)
405
406
407     def exec2(self, cmdline, argv):
408         """exec2(eConsoleAppContainer self, char const * cmdline, char const *const [] argv) -> int"""
409         return _enigma.eConsoleAppContainer_exec2(self, cmdline, argv)
410
411
412     def getPID(self):
413         """getPID(eConsoleAppContainer self) -> int"""
414         return _enigma.eConsoleAppContainer_getPID(self)
415
416
417     def kill(self):
418         """kill(eConsoleAppContainer self)"""
419         return _enigma.eConsoleAppContainer_kill(self)
420
421
422     def sendCtrlC(self):
423         """sendCtrlC(eConsoleAppContainer self)"""
424         return _enigma.eConsoleAppContainer_sendCtrlC(self)
425
426
427     def sendEOF(self):
428         """sendEOF(eConsoleAppContainer self)"""
429         return _enigma.eConsoleAppContainer_sendEOF(self)
430
431
432     def write(self, data, len):
433         """write(eConsoleAppContainer self, char const * data, int len)"""
434         return _enigma.eConsoleAppContainer_write(self, data, len)
435
436
437     def setFileFD(self, num, fd):
438         """setFileFD(eConsoleAppContainer self, int num, int fd)"""
439         return _enigma.eConsoleAppContainer_setFileFD(self, num, fd)
440
441
442     def running(self):
443         """running(eConsoleAppContainer self) -> bool"""
444         return _enigma.eConsoleAppContainer_running(self)
445
446     dataAvail = _swig_property(_enigma.eConsoleAppContainer_dataAvail_get, _enigma.eConsoleAppContainer_dataAvail_set)
447     stdoutAvail = _swig_property(_enigma.eConsoleAppContainer_stdoutAvail_get, _enigma.eConsoleAppContainer_stdoutAvail_set)
448     stderrAvail = _swig_property(_enigma.eConsoleAppContainer_stderrAvail_get, _enigma.eConsoleAppContainer_stderrAvail_set)
449     dataSent = _swig_property(_enigma.eConsoleAppContainer_dataSent_get, _enigma.eConsoleAppContainer_dataSent_set)
450     appClosed = _swig_property(_enigma.eConsoleAppContainer_appClosed_get, _enigma.eConsoleAppContainer_appClosed_set)
451
452     def execute(self, *args):
453         if len(args) > 1:
454             return self.exec2(args[0], args[1:])
455         return self.exec1(args[0])
456 eConsoleAppContainer.setCWD = new_instancemethod(_enigma.eConsoleAppContainer_setCWD, None, eConsoleAppContainer)
457 eConsoleAppContainer.exec1 = new_instancemethod(_enigma.eConsoleAppContainer_exec1, None, eConsoleAppContainer)
458 eConsoleAppContainer.exec2 = new_instancemethod(_enigma.eConsoleAppContainer_exec2, None, eConsoleAppContainer)
459 eConsoleAppContainer.getPID = new_instancemethod(_enigma.eConsoleAppContainer_getPID, None, eConsoleAppContainer)
460 eConsoleAppContainer.kill = new_instancemethod(_enigma.eConsoleAppContainer_kill, None, eConsoleAppContainer)
461 eConsoleAppContainer.sendCtrlC = new_instancemethod(_enigma.eConsoleAppContainer_sendCtrlC, None, eConsoleAppContainer)
462 eConsoleAppContainer.sendEOF = new_instancemethod(_enigma.eConsoleAppContainer_sendEOF, None, eConsoleAppContainer)
463 eConsoleAppContainer.write = new_instancemethod(_enigma.eConsoleAppContainer_write, None, eConsoleAppContainer)
464 eConsoleAppContainer.setFileFD = new_instancemethod(_enigma.eConsoleAppContainer_setFileFD, None, eConsoleAppContainer)
465 eConsoleAppContainer.running = new_instancemethod(_enigma.eConsoleAppContainer_running, None, eConsoleAppContainer)
466 eConsoleAppContainer_swigregister = _enigma.eConsoleAppContainer_swigregister
467 eConsoleAppContainer_swigregister(eConsoleAppContainer)
468
469 class eDict(object):
470     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
471     __repr__ = _swig_repr
472
473     def __init__(self):
474         """__init__(eDict self) -> eDict"""
475         _enigma.eDict_swiginit(self, _enigma.new_eDict())
476     __swig_destroy__ = _enigma.delete_eDict
477 eDict.flag = new_instancemethod(_enigma.eDict_flag, None, eDict)
478 eDict.setFlag = new_instancemethod(_enigma.eDict_setFlag, None, eDict)
479 eDict.string = new_instancemethod(_enigma.eDict_string, None, eDict)
480 eDict.setString = new_instancemethod(_enigma.eDict_setString, None, eDict)
481 eDict_swigregister = _enigma.eDict_swigregister
482 eDict_swigregister(eDict)
483
484 class eDictList(object):
485     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
486     __repr__ = _swig_repr
487
488     def __init__(self):
489         """__init__(eDictList self) -> eDictList"""
490         _enigma.eDictList_swiginit(self, _enigma.new_eDictList())
491     __swig_destroy__ = _enigma.delete_eDictList
492 eDictList.push_back = new_instancemethod(_enigma.eDictList_push_back, None, eDictList)
493 eDictList_swigregister = _enigma.eDictList_swigregister
494 eDictList_swigregister(eDictList)
495
496 class eEnv(object):
497     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
498     __repr__ = _swig_repr
499
500     def resolve(path):
501         """resolve(std::string const & path) -> std::string"""
502         return _enigma.eEnv_resolve(path)
503
504     resolve = staticmethod(resolve)
505
506     def __init__(self):
507         """__init__(eEnv self) -> eEnv"""
508         _enigma.eEnv_swiginit(self, _enigma.new_eEnv())
509     __swig_destroy__ = _enigma.delete_eEnv
510 eEnv_swigregister = _enigma.eEnv_swigregister
511 eEnv_swigregister(eEnv)
512
513 def eEnv_resolve(path):
514     """eEnv_resolve(std::string const & path) -> std::string"""
515     return _enigma.eEnv_resolve(path)
516
517
518 def segfault():
519     return _enigma.segfault()
520 segfault = _enigma.segfault
521 NULL = _enigma.NULL
522
523 def ptrAssert(p, mangled_type):
524     return _enigma.ptrAssert(p, mangled_type)
525 ptrAssert = _enigma.ptrAssert
526 MALLOC = _enigma.MALLOC
527 NEW = _enigma.NEW
528 class BufferPtr(object):
529     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
530     __repr__ = _swig_repr
531
532     def __init__(self, *args):
533         _enigma.BufferPtr_swiginit(self, _enigma.new_BufferPtr(*args))
534     __swig_destroy__ = _enigma.delete_BufferPtr
535 BufferPtr.__ref__ = new_instancemethod(_enigma.BufferPtr___ref__, None, BufferPtr)
536 BufferPtr.getPtrString = new_instancemethod(_enigma.BufferPtr_getPtrString, None, BufferPtr)
537 BufferPtr.__deref__ = new_instancemethod(_enigma.BufferPtr___deref__, None, BufferPtr)
538 BufferPtr.data = new_instancemethod(_enigma.BufferPtr_data, None, BufferPtr)
539 BufferPtr.size = new_instancemethod(_enigma.BufferPtr_size, None, BufferPtr)
540 BufferPtr.setBuffer = new_instancemethod(_enigma.BufferPtr_setBuffer, None, BufferPtr)
541 BufferPtr.setSize = new_instancemethod(_enigma.BufferPtr_setSize, None, BufferPtr)
542 BufferPtr_swigregister = _enigma.BufferPtr_swigregister
543 BufferPtr_swigregister(BufferPtr)
544
545 class eServiceEvent(object):
546     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
547     __repr__ = _swig_repr
548
549     def __init__(self, *args):
550         _enigma.eServiceEvent_swiginit(self, _enigma.new_eServiceEvent(*args))
551     __swig_destroy__ = _enigma.delete_eServiceEvent
552     setEPGLanguage = staticmethod(_enigma.eServiceEvent_setEPGLanguage)
553
554     def getBeginTime(self):
555         """getBeginTime(eServiceEvent self) -> time_t"""
556         return _enigma.eServiceEvent_getBeginTime(self)
557
558
559     def getDuration(self):
560         """getDuration(eServiceEvent self) -> int"""
561         return _enigma.eServiceEvent_getDuration(self)
562
563
564     def getEventId(self):
565         """getEventId(eServiceEvent self) -> int"""
566         return _enigma.eServiceEvent_getEventId(self)
567
568
569     def getEventName(self):
570         """getEventName(eServiceEvent self) -> std::string"""
571         return _enigma.eServiceEvent_getEventName(self)
572
573
574     def getShortDescription(self):
575         """getShortDescription(eServiceEvent self) -> std::string"""
576         return _enigma.eServiceEvent_getShortDescription(self)
577
578
579     def getExtendedDescription(self, original=False):
580         """
581         getExtendedDescription(eServiceEvent self, bool original=False) -> std::string
582         getExtendedDescription(eServiceEvent self) -> std::string
583         """
584         return _enigma.eServiceEvent_getExtendedDescription(self, original)
585
586
587     def getBeginTimeString(self):
588         """getBeginTimeString(eServiceEvent self) -> std::string"""
589         return _enigma.eServiceEvent_getBeginTimeString(self)
590
591
592     def getNumComponent(self):
593         """getNumComponent(eServiceEvent self) -> int"""
594         return _enigma.eServiceEvent_getNumComponent(self)
595
596
597     def getComponentData(self, *args):
598         """
599         getComponentData(eServiceEvent self, int tagnum) -> eComponentData
600         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 > > >
601         """
602         return _enigma.eServiceEvent_getComponentData(self, *args)
603
604
605     def getNumOfLinkageServices(self):
606         """getNumOfLinkageServices(eServiceEvent self) -> int"""
607         return _enigma.eServiceEvent_getNumOfLinkageServices(self)
608
609
610     def getLinkageService(self, parent, num):
611         """getLinkageService(eServiceEvent self, eServiceReference parent, int num)"""
612         return _enigma.eServiceEvent_getLinkageService(self, parent, num)
613
614 eServiceEvent.__ref__ = new_instancemethod(_enigma.eServiceEvent___ref__, None, eServiceEvent)
615 eServiceEvent.getPtrString = new_instancemethod(_enigma.eServiceEvent_getPtrString, None, eServiceEvent)
616 eServiceEvent.__deref__ = new_instancemethod(_enigma.eServiceEvent___deref__, None, eServiceEvent)
617 eServiceEvent.getBeginTime = new_instancemethod(_enigma.eServiceEvent_getBeginTime, None, eServiceEvent)
618 eServiceEvent.getDuration = new_instancemethod(_enigma.eServiceEvent_getDuration, None, eServiceEvent)
619 eServiceEvent.getEventId = new_instancemethod(_enigma.eServiceEvent_getEventId, None, eServiceEvent)
620 eServiceEvent.getEventName = new_instancemethod(_enigma.eServiceEvent_getEventName, None, eServiceEvent)
621 eServiceEvent.getShortDescription = new_instancemethod(_enigma.eServiceEvent_getShortDescription, None, eServiceEvent)
622 eServiceEvent.getExtendedDescription = new_instancemethod(_enigma.eServiceEvent_getExtendedDescription, None, eServiceEvent)
623 eServiceEvent.getBeginTimeString = new_instancemethod(_enigma.eServiceEvent_getBeginTimeString, None, eServiceEvent)
624 eServiceEvent.getNumComponent = new_instancemethod(_enigma.eServiceEvent_getNumComponent, None, eServiceEvent)
625 eServiceEvent.getComponentData = new_instancemethod(_enigma.eServiceEvent_getComponentData, None, eServiceEvent)
626 eServiceEvent.getNumOfLinkageServices = new_instancemethod(_enigma.eServiceEvent_getNumOfLinkageServices, None, eServiceEvent)
627 eServiceEvent.getLinkageService = new_instancemethod(_enigma.eServiceEvent_getLinkageService, None, eServiceEvent)
628 eServiceEvent_swigregister = _enigma.eServiceEvent_swigregister
629 eServiceEvent_swigregister(eServiceEvent)
630
631 def eServiceEvent_setEPGLanguage(language):
632     return _enigma.eServiceEvent_setEPGLanguage(language)
633 eServiceEvent_setEPGLanguage = _enigma.eServiceEvent_setEPGLanguage
634
635 CT_MPEG2 = _enigma.CT_MPEG2
636 CT_H264 = _enigma.CT_H264
637 CT_MPEG1 = _enigma.CT_MPEG1
638 CT_MPEG4_PART2 = _enigma.CT_MPEG4_PART2
639 CT_VC1 = _enigma.CT_VC1
640 CT_VC1_SIMPLE_MAIN = _enigma.CT_VC1_SIMPLE_MAIN
641 CT_H265 = _enigma.CT_H265
642 CT_DIVX311 = _enigma.CT_DIVX311
643 CT_DIVX4 = _enigma.CT_DIVX4
644 CT_SPARK = _enigma.CT_SPARK
645 CT_VP6 = _enigma.CT_VP6
646 CT_VP8 = _enigma.CT_VP8
647 CT_VP9 = _enigma.CT_VP9
648 CT_H263 = _enigma.CT_H263
649 CT_MJPEG = _enigma.CT_MJPEG
650 CT_REAL = _enigma.CT_REAL
651 CT_AVS = _enigma.CT_AVS
652 CT_UNKNOWN = _enigma.CT_UNKNOWN
653 class eServiceReference(object):
654     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
655     __repr__ = _swig_repr
656     idInvalid = _enigma.eServiceReference_idInvalid
657     idStructure = _enigma.eServiceReference_idStructure
658     idDVB = _enigma.eServiceReference_idDVB
659     idFile = _enigma.eServiceReference_idFile
660     idM2TS = _enigma.eServiceReference_idM2TS
661     idDB = _enigma.eServiceReference_idDB
662     idUser = _enigma.eServiceReference_idUser
663     idGST = _enigma.eServiceReference_idGST
664     idDVD = _enigma.eServiceReference_idDVD
665     idURI = _enigma.eServiceReference_idURI
666     idStream = _enigma.eServiceReference_idStream
667     type = _swig_property(_enigma.eServiceReference_type_get, _enigma.eServiceReference_type_set)
668     isDirectory = _enigma.eServiceReference_isDirectory
669     mustDescent = _enigma.eServiceReference_mustDescent
670     canDescent = _enigma.eServiceReference_canDescent
671     flagDirectory = _enigma.eServiceReference_flagDirectory
672     shouldSort = _enigma.eServiceReference_shouldSort
673     hasSortKey = _enigma.eServiceReference_hasSortKey
674     sort1 = _enigma.eServiceReference_sort1
675     isMarker = _enigma.eServiceReference_isMarker
676     isGroup = _enigma.eServiceReference_isGroup
677     isLive = _enigma.eServiceReference_isLive
678     isMulticast = _enigma.eServiceReference_isMulticast
679     mustJoinMulticastGroup = _enigma.eServiceReference_mustJoinMulticastGroup
680     flags = _swig_property(_enigma.eServiceReference_flags_get, _enigma.eServiceReference_flags_set)
681
682     def getSortKey(self):
683         """getSortKey(eServiceReference self) -> int"""
684         return _enigma.eServiceReference_getSortKey(self)
685
686
687     def getPath(self):
688         """getPath(eServiceReference self) -> std::string"""
689         return _enigma.eServiceReference_getPath(self)
690
691
692     def setPath(self, n, decode_path=False):
693         """
694         setPath(eServiceReference self, std::string const & n, bool decode_path=False)
695         setPath(eServiceReference self, std::string const & n)
696         """
697         return _enigma.eServiceReference_setPath(self, n, decode_path)
698
699
700     def getUnsignedData(self, num):
701         """getUnsignedData(eServiceReference self, unsigned int num) -> unsigned int"""
702         return _enigma.eServiceReference_getUnsignedData(self, num)
703
704
705     def getData(self, num):
706         """getData(eServiceReference self, unsigned int num) -> int"""
707         return _enigma.eServiceReference_getData(self, num)
708
709
710     def setUnsignedData(self, num, val):
711         """setUnsignedData(eServiceReference self, unsigned int num, unsigned int val)"""
712         return _enigma.eServiceReference_setUnsignedData(self, num, val)
713
714
715     def setData(self, num, val):
716         """setData(eServiceReference self, unsigned int num, int val)"""
717         return _enigma.eServiceReference_setData(self, num, val)
718
719
720     def getName(self):
721         """getName(eServiceReference self) -> std::string"""
722         return _enigma.eServiceReference_getName(self)
723
724
725     def setName(self, n):
726         """setName(eServiceReference self, std::string const & n)"""
727         return _enigma.eServiceReference_setName(self, n)
728
729
730     def setUserAgent(self, uA):
731         """setUserAgent(eServiceReference self, std::string const & uA)"""
732         return _enigma.eServiceReference_setUserAgent(self, uA)
733
734
735     def getUserAgent(self):
736         """getUserAgent(eServiceReference self) -> std::string const"""
737         return _enigma.eServiceReference_getUserAgent(self)
738
739
740     def setTransportHeaders(self, headers):
741         """setTransportHeaders(eServiceReference self, StringMap headers)"""
742         return _enigma.eServiceReference_setTransportHeaders(self, headers)
743
744
745     def getTransportHeaders(self):
746         """getTransportHeaders(eServiceReference self) -> StringMap"""
747         return _enigma.eServiceReference_getTransportHeaders(self)
748
749
750     def getSuburi(self):
751         """getSuburi(eServiceReference self) -> std::string"""
752         return _enigma.eServiceReference_getSuburi(self)
753
754
755     def setSuburi(self, sU):
756         """setSuburi(eServiceReference self, std::string const & sU)"""
757         return _enigma.eServiceReference_setSuburi(self, sU)
758
759
760     def __init__(self, *args):
761         """
762         __init__(eServiceReference self) -> eServiceReference
763         __init__(eServiceReference self, int type, int flags, std::string const & p) -> eServiceReference
764         __init__(eServiceReference self, std::string const & string) -> eServiceReference
765         """
766         _enigma.eServiceReference_swiginit(self, _enigma.new_eServiceReference(*args))
767
768     def toString(self):
769         """toString(eServiceReference self) -> std::string"""
770         return _enigma.eServiceReference_toString(self)
771
772
773     def toCompareString(self):
774         """toCompareString(eServiceReference self) -> std::string"""
775         return _enigma.eServiceReference_toCompareString(self)
776
777
778     def __eq__(self, c):
779         """__eq__(eServiceReference self, eServiceReference c) -> bool"""
780         return _enigma.eServiceReference___eq__(self, c)
781
782
783     def __ne__(self, c):
784         """__ne__(eServiceReference self, eServiceReference c) -> bool"""
785         return _enigma.eServiceReference___ne__(self, c)
786
787
788     def __lt__(self, c):
789         """__lt__(eServiceReference self, eServiceReference c) -> bool"""
790         return _enigma.eServiceReference___lt__(self, c)
791
792
793     def valid(self):
794         """valid(eServiceReference self) -> int"""
795         return _enigma.eServiceReference_valid(self)
796
797
798     def compare(self, ref):
799         """compare(eServiceReference self, eServiceReference ref) -> int"""
800         return _enigma.eServiceReference_compare(self, ref)
801
802
803     def hash(self):
804         """hash(eServiceReference self) -> long"""
805         return _enigma.eServiceReference_hash(self)
806
807     __swig_destroy__ = _enigma.delete_eServiceReference
808 eServiceReference.getSortKey = new_instancemethod(_enigma.eServiceReference_getSortKey, None, eServiceReference)
809 eServiceReference.getPath = new_instancemethod(_enigma.eServiceReference_getPath, None, eServiceReference)
810 eServiceReference.setPath = new_instancemethod(_enigma.eServiceReference_setPath, None, eServiceReference)
811 eServiceReference.getUnsignedData = new_instancemethod(_enigma.eServiceReference_getUnsignedData, None, eServiceReference)
812 eServiceReference.getData = new_instancemethod(_enigma.eServiceReference_getData, None, eServiceReference)
813 eServiceReference.setUnsignedData = new_instancemethod(_enigma.eServiceReference_setUnsignedData, None, eServiceReference)
814 eServiceReference.setData = new_instancemethod(_enigma.eServiceReference_setData, None, eServiceReference)
815 eServiceReference.getName = new_instancemethod(_enigma.eServiceReference_getName, None, eServiceReference)
816 eServiceReference.setName = new_instancemethod(_enigma.eServiceReference_setName, None, eServiceReference)
817 eServiceReference.setUserAgent = new_instancemethod(_enigma.eServiceReference_setUserAgent, None, eServiceReference)
818 eServiceReference.getUserAgent = new_instancemethod(_enigma.eServiceReference_getUserAgent, None, eServiceReference)
819 eServiceReference.setTransportHeaders = new_instancemethod(_enigma.eServiceReference_setTransportHeaders, None, eServiceReference)
820 eServiceReference.getTransportHeaders = new_instancemethod(_enigma.eServiceReference_getTransportHeaders, None, eServiceReference)
821 eServiceReference.getSuburi = new_instancemethod(_enigma.eServiceReference_getSuburi, None, eServiceReference)
822 eServiceReference.setSuburi = new_instancemethod(_enigma.eServiceReference_setSuburi, None, eServiceReference)
823 eServiceReference.toString = new_instancemethod(_enigma.eServiceReference_toString, None, eServiceReference)
824 eServiceReference.toCompareString = new_instancemethod(_enigma.eServiceReference_toCompareString, None, eServiceReference)
825 eServiceReference.__eq__ = new_instancemethod(_enigma.eServiceReference___eq__, None, eServiceReference)
826 eServiceReference.__ne__ = new_instancemethod(_enigma.eServiceReference___ne__, None, eServiceReference)
827 eServiceReference.__lt__ = new_instancemethod(_enigma.eServiceReference___lt__, None, eServiceReference)
828 eServiceReference.valid = new_instancemethod(_enigma.eServiceReference_valid, None, eServiceReference)
829 eServiceReference.compare = new_instancemethod(_enigma.eServiceReference_compare, None, eServiceReference)
830 eServiceReference.hash = new_instancemethod(_enigma.eServiceReference_hash, None, eServiceReference)
831 eServiceReference_swigregister = _enigma.eServiceReference_swigregister
832 eServiceReference_swigregister(eServiceReference)
833
834 eServiceReference.__hash__ = eServiceReference.hash
835
836 def New_eServiceReference(ref):
837     return _enigma.New_eServiceReference(ref)
838 New_eServiceReference = _enigma.New_eServiceReference
839 class iStaticServiceInformationPtr(object):
840     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
841     __repr__ = _swig_repr
842
843     def __init__(self, *args):
844         _enigma.iStaticServiceInformationPtr_swiginit(self, _enigma.new_iStaticServiceInformationPtr(*args))
845     __swig_destroy__ = _enigma.delete_iStaticServiceInformationPtr
846
847     def getName(self, ref):
848         """getName(iStaticServiceInformationPtr self, eServiceReference ref)"""
849         return _enigma.iStaticServiceInformationPtr_getName(self, ref)
850
851
852     def getLength(self, ref):
853         """getLength(iStaticServiceInformationPtr self, eServiceReference ref) -> int"""
854         return _enigma.iStaticServiceInformationPtr_getLength(self, ref)
855
856
857     def getLength64(self, ref):
858         """getLength64(iStaticServiceInformationPtr self, eServiceReference ref) -> int64_t"""
859         return _enigma.iStaticServiceInformationPtr_getLength64(self, ref)
860
861
862     def getEvent(self, ref, start_time=-1):
863         """
864         getEvent(iStaticServiceInformationPtr self, eServiceReference ref, time_t start_time=-1)
865         getEvent(iStaticServiceInformationPtr self, eServiceReference ref)
866         """
867         return _enigma.iStaticServiceInformationPtr_getEvent(self, ref, start_time)
868
869
870     def isPlayable(self, ref, ignore, simulate=False):
871         """
872         isPlayable(iStaticServiceInformationPtr self, eServiceReference ref, eServiceReference ignore, bool simulate=False) -> int
873         isPlayable(iStaticServiceInformationPtr self, eServiceReference ref, eServiceReference ignore) -> int
874         """
875         return _enigma.iStaticServiceInformationPtr_isPlayable(self, ref, ignore, simulate)
876
877
878     def getInfo(self, ref, w):
879         """getInfo(iStaticServiceInformationPtr self, eServiceReference ref, int w) -> int"""
880         return _enigma.iStaticServiceInformationPtr_getInfo(self, ref, w)
881
882
883     def getInfoString(self, ref, w):
884         """getInfoString(iStaticServiceInformationPtr self, eServiceReference ref, int w) -> std::string"""
885         return _enigma.iStaticServiceInformationPtr_getInfoString(self, ref, w)
886
887
888     def getInfoObject(self, ref, w):
889         """getInfoObject(iStaticServiceInformationPtr self, eServiceReference ref, int w) -> boost::any"""
890         return _enigma.iStaticServiceInformationPtr_getInfoObject(self, ref, w)
891
892
893     def setInfo(self, ref, w, v):
894         """setInfo(iStaticServiceInformationPtr self, eServiceReference ref, int w, int v) -> int"""
895         return _enigma.iStaticServiceInformationPtr_setInfo(self, ref, w, v)
896
897
898     def setInfoString(self, ref, w, v):
899         """setInfoString(iStaticServiceInformationPtr self, eServiceReference ref, int w, char const * v) -> int"""
900         return _enigma.iStaticServiceInformationPtr_setInfoString(self, ref, w, v)
901
902 iStaticServiceInformationPtr.__ref__ = new_instancemethod(_enigma.iStaticServiceInformationPtr___ref__, None, iStaticServiceInformationPtr)
903 iStaticServiceInformationPtr.getPtrString = new_instancemethod(_enigma.iStaticServiceInformationPtr_getPtrString, None, iStaticServiceInformationPtr)
904 iStaticServiceInformationPtr.__deref__ = new_instancemethod(_enigma.iStaticServiceInformationPtr___deref__, None, iStaticServiceInformationPtr)
905 iStaticServiceInformationPtr.getName = new_instancemethod(_enigma.iStaticServiceInformationPtr_getName, None, iStaticServiceInformationPtr)
906 iStaticServiceInformationPtr.getLength = new_instancemethod(_enigma.iStaticServiceInformationPtr_getLength, None, iStaticServiceInformationPtr)
907 iStaticServiceInformationPtr.getLength64 = new_instancemethod(_enigma.iStaticServiceInformationPtr_getLength64, None, iStaticServiceInformationPtr)
908 iStaticServiceInformationPtr.getEvent = new_instancemethod(_enigma.iStaticServiceInformationPtr_getEvent, None, iStaticServiceInformationPtr)
909 iStaticServiceInformationPtr.isPlayable = new_instancemethod(_enigma.iStaticServiceInformationPtr_isPlayable, None, iStaticServiceInformationPtr)
910 iStaticServiceInformationPtr.getInfo = new_instancemethod(_enigma.iStaticServiceInformationPtr_getInfo, None, iStaticServiceInformationPtr)
911 iStaticServiceInformationPtr.getInfoString = new_instancemethod(_enigma.iStaticServiceInformationPtr_getInfoString, None, iStaticServiceInformationPtr)
912 iStaticServiceInformationPtr.getInfoObject = new_instancemethod(_enigma.iStaticServiceInformationPtr_getInfoObject, None, iStaticServiceInformationPtr)
913 iStaticServiceInformationPtr.setInfo = new_instancemethod(_enigma.iStaticServiceInformationPtr_setInfo, None, iStaticServiceInformationPtr)
914 iStaticServiceInformationPtr.setInfoString = new_instancemethod(_enigma.iStaticServiceInformationPtr_setInfoString, None, iStaticServiceInformationPtr)
915 iStaticServiceInformationPtr_swigregister = _enigma.iStaticServiceInformationPtr_swigregister
916 iStaticServiceInformationPtr_swigregister(iStaticServiceInformationPtr)
917
918 class iServiceInformation_ENUMS(object):
919     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
920
921     def __init__(self, *args, **kwargs):
922         raise AttributeError("No constructor defined")
923     __repr__ = _swig_repr
924     sIsCrypted = _enigma.iServiceInformation_ENUMS_sIsCrypted
925     sAspect = _enigma.iServiceInformation_ENUMS_sAspect
926     sFrameRate = _enigma.iServiceInformation_ENUMS_sFrameRate
927     sProgressive = _enigma.iServiceInformation_ENUMS_sProgressive
928     sIsMultichannel = _enigma.iServiceInformation_ENUMS_sIsMultichannel
929     sEotf = _enigma.iServiceInformation_ENUMS_sEotf
930     sVideoPID = _enigma.iServiceInformation_ENUMS_sVideoPID
931     sAudioPID = _enigma.iServiceInformation_ENUMS_sAudioPID
932     sPCRPID = _enigma.iServiceInformation_ENUMS_sPCRPID
933     sPMTPID = _enigma.iServiceInformation_ENUMS_sPMTPID
934     sTXTPID = _enigma.iServiceInformation_ENUMS_sTXTPID
935     sSID = _enigma.iServiceInformation_ENUMS_sSID
936     sONID = _enigma.iServiceInformation_ENUMS_sONID
937     sTSID = _enigma.iServiceInformation_ENUMS_sTSID
938     sNamespace = _enigma.iServiceInformation_ENUMS_sNamespace
939     sProvider = _enigma.iServiceInformation_ENUMS_sProvider
940     sDescription = _enigma.iServiceInformation_ENUMS_sDescription
941     sDatabaseFileId = _enigma.iServiceInformation_ENUMS_sDatabaseFileId
942     sServiceref = _enigma.iServiceInformation_ENUMS_sServiceref
943     sTimeCreate = _enigma.iServiceInformation_ENUMS_sTimeCreate
944     sFileSize = _enigma.iServiceInformation_ENUMS_sFileSize
945     sCAIDs = _enigma.iServiceInformation_ENUMS_sCAIDs
946     sCAIDPIDs = _enigma.iServiceInformation_ENUMS_sCAIDPIDs
947     sVideoType = _enigma.iServiceInformation_ENUMS_sVideoType
948     sAudioType = _enigma.iServiceInformation_ENUMS_sAudioType
949     sTags = _enigma.iServiceInformation_ENUMS_sTags
950     sDVBState = _enigma.iServiceInformation_ENUMS_sDVBState
951     sVideoHeight = _enigma.iServiceInformation_ENUMS_sVideoHeight
952     sVideoWidth = _enigma.iServiceInformation_ENUMS_sVideoWidth
953     sTransponderData = _enigma.iServiceInformation_ENUMS_sTransponderData
954     sCurrentChapter = _enigma.iServiceInformation_ENUMS_sCurrentChapter
955     sCurrentTitle = _enigma.iServiceInformation_ENUMS_sCurrentTitle
956     sTotalChapters = _enigma.iServiceInformation_ENUMS_sTotalChapters
957     sTotalTitles = _enigma.iServiceInformation_ENUMS_sTotalTitles
958     sTagTitle = _enigma.iServiceInformation_ENUMS_sTagTitle
959     sTagTitleSortname = _enigma.iServiceInformation_ENUMS_sTagTitleSortname
960     sTagArtist = _enigma.iServiceInformation_ENUMS_sTagArtist
961     sTagArtistSortname = _enigma.iServiceInformation_ENUMS_sTagArtistSortname
962     sTagAlbum = _enigma.iServiceInformation_ENUMS_sTagAlbum
963     sTagAlbumSortname = _enigma.iServiceInformation_ENUMS_sTagAlbumSortname
964     sTagComposer = _enigma.iServiceInformation_ENUMS_sTagComposer
965     sTagDate = _enigma.iServiceInformation_ENUMS_sTagDate
966     sTagGenre = _enigma.iServiceInformation_ENUMS_sTagGenre
967     sTagComment = _enigma.iServiceInformation_ENUMS_sTagComment
968     sTagExtendedComment = _enigma.iServiceInformation_ENUMS_sTagExtendedComment
969     sTagTrackNumber = _enigma.iServiceInformation_ENUMS_sTagTrackNumber
970     sTagTrackCount = _enigma.iServiceInformation_ENUMS_sTagTrackCount
971     sTagAlbumVolumeNumber = _enigma.iServiceInformation_ENUMS_sTagAlbumVolumeNumber
972     sTagAlbumVolumeCount = _enigma.iServiceInformation_ENUMS_sTagAlbumVolumeCount
973     sTagLocation = _enigma.iServiceInformation_ENUMS_sTagLocation
974     sTagHomepage = _enigma.iServiceInformation_ENUMS_sTagHomepage
975     sTagDescription = _enigma.iServiceInformation_ENUMS_sTagDescription
976     sTagVersion = _enigma.iServiceInformation_ENUMS_sTagVersion
977     sTagISRC = _enigma.iServiceInformation_ENUMS_sTagISRC
978     sTagOrganization = _enigma.iServiceInformation_ENUMS_sTagOrganization
979     sTagCopyright = _enigma.iServiceInformation_ENUMS_sTagCopyright
980     sTagCopyrightURI = _enigma.iServiceInformation_ENUMS_sTagCopyrightURI
981     sTagContact = _enigma.iServiceInformation_ENUMS_sTagContact
982     sTagLicense = _enigma.iServiceInformation_ENUMS_sTagLicense
983     sTagLicenseURI = _enigma.iServiceInformation_ENUMS_sTagLicenseURI
984     sTagPerformer = _enigma.iServiceInformation_ENUMS_sTagPerformer
985     sTagCodec = _enigma.iServiceInformation_ENUMS_sTagCodec
986     sTagVideoCodec = _enigma.iServiceInformation_ENUMS_sTagVideoCodec
987     sTagAudioCodec = _enigma.iServiceInformation_ENUMS_sTagAudioCodec
988     sTagBitrate = _enigma.iServiceInformation_ENUMS_sTagBitrate
989     sTagNominalBitrate = _enigma.iServiceInformation_ENUMS_sTagNominalBitrate
990     sTagMinimumBitrate = _enigma.iServiceInformation_ENUMS_sTagMinimumBitrate
991     sTagMaximumBitrate = _enigma.iServiceInformation_ENUMS_sTagMaximumBitrate
992     sTagSerial = _enigma.iServiceInformation_ENUMS_sTagSerial
993     sTagEncoder = _enigma.iServiceInformation_ENUMS_sTagEncoder
994     sTagEncoderVersion = _enigma.iServiceInformation_ENUMS_sTagEncoderVersion
995     sTagTrackGain = _enigma.iServiceInformation_ENUMS_sTagTrackGain
996     sTagTrackPeak = _enigma.iServiceInformation_ENUMS_sTagTrackPeak
997     sTagAlbumGain = _enigma.iServiceInformation_ENUMS_sTagAlbumGain
998     sTagAlbumPeak = _enigma.iServiceInformation_ENUMS_sTagAlbumPeak
999     sTagReferenceLevel = _enigma.iServiceInformation_ENUMS_sTagReferenceLevel
1000     sTagLanguageCode = _enigma.iServiceInformation_ENUMS_sTagLanguageCode
1001     sTagImage = _enigma.iServiceInformation_ENUMS_sTagImage
1002     sTagPreviewImage = _enigma.iServiceInformation_ENUMS_sTagPreviewImage
1003     sTagAttachment = _enigma.iServiceInformation_ENUMS_sTagAttachment
1004     sTagBeatsPerMinute = _enigma.iServiceInformation_ENUMS_sTagBeatsPerMinute
1005     sTagKeywords = _enigma.iServiceInformation_ENUMS_sTagKeywords
1006     sTagCRC = _enigma.iServiceInformation_ENUMS_sTagCRC
1007     sTagChannelMode = _enigma.iServiceInformation_ENUMS_sTagChannelMode
1008     sTransferBPS = _enigma.iServiceInformation_ENUMS_sTransferBPS
1009     sLastUpdated = _enigma.iServiceInformation_ENUMS_sLastUpdated
1010     sAngle = _enigma.iServiceInformation_ENUMS_sAngle
1011     sUser = _enigma.iServiceInformation_ENUMS_sUser
1012     sErrorText = _enigma.iServiceInformation_ENUMS_sErrorText
1013     resNA = _enigma.iServiceInformation_ENUMS_resNA
1014     resIsString = _enigma.iServiceInformation_ENUMS_resIsString
1015     resIsPyObject = _enigma.iServiceInformation_ENUMS_resIsPyObject
1016 iServiceInformation_ENUMS_swigregister = _enigma.iServiceInformation_ENUMS_swigregister
1017 iServiceInformation_ENUMS_swigregister(iServiceInformation_ENUMS)
1018
1019 iServiceInformation = iServiceInformation_ENUMS
1020 class iServiceInformationPtr(object):
1021     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1022     __repr__ = _swig_repr
1023
1024     def __init__(self, *args):
1025         _enigma.iServiceInformationPtr_swiginit(self, _enigma.new_iServiceInformationPtr(*args))
1026     __swig_destroy__ = _enigma.delete_iServiceInformationPtr
1027
1028     def getName(self):
1029         """getName(iServiceInformationPtr self)"""
1030         return _enigma.iServiceInformationPtr_getName(self)
1031
1032
1033     def getEvent(self, nownext):
1034         """getEvent(iServiceInformationPtr self, int nownext)"""
1035         return _enigma.iServiceInformationPtr_getEvent(self, nownext)
1036
1037
1038     def getInfo(self, w):
1039         """getInfo(iServiceInformationPtr self, int w) -> int"""
1040         return _enigma.iServiceInformationPtr_getInfo(self, w)
1041
1042
1043     def getInfoString(self, w):
1044         """getInfoString(iServiceInformationPtr self, int w) -> std::string"""
1045         return _enigma.iServiceInformationPtr_getInfoString(self, w)
1046
1047
1048     def getInfoObject(self, w):
1049         """getInfoObject(iServiceInformationPtr self, int w) -> boost::any"""
1050         return _enigma.iServiceInformationPtr_getInfoObject(self, w)
1051
1052
1053     def setInfo(self, w, v):
1054         """setInfo(iServiceInformationPtr self, int w, int v) -> int"""
1055         return _enigma.iServiceInformationPtr_setInfo(self, w, v)
1056
1057
1058     def setInfoString(self, w, v):
1059         """setInfoString(iServiceInformationPtr self, int w, char const * v) -> int"""
1060         return _enigma.iServiceInformationPtr_setInfoString(self, w, v)
1061
1062 iServiceInformationPtr.__ref__ = new_instancemethod(_enigma.iServiceInformationPtr___ref__, None, iServiceInformationPtr)
1063 iServiceInformationPtr.getPtrString = new_instancemethod(_enigma.iServiceInformationPtr_getPtrString, None, iServiceInformationPtr)
1064 iServiceInformationPtr.__deref__ = new_instancemethod(_enigma.iServiceInformationPtr___deref__, None, iServiceInformationPtr)
1065 iServiceInformationPtr.getName = new_instancemethod(_enigma.iServiceInformationPtr_getName, None, iServiceInformationPtr)
1066 iServiceInformationPtr.getEvent = new_instancemethod(_enigma.iServiceInformationPtr_getEvent, None, iServiceInformationPtr)
1067 iServiceInformationPtr.getInfo = new_instancemethod(_enigma.iServiceInformationPtr_getInfo, None, iServiceInformationPtr)
1068 iServiceInformationPtr.getInfoString = new_instancemethod(_enigma.iServiceInformationPtr_getInfoString, None, iServiceInformationPtr)
1069 iServiceInformationPtr.getInfoObject = new_instancemethod(_enigma.iServiceInformationPtr_getInfoObject, None, iServiceInformationPtr)
1070 iServiceInformationPtr.setInfo = new_instancemethod(_enigma.iServiceInformationPtr_setInfo, None, iServiceInformationPtr)
1071 iServiceInformationPtr.setInfoString = new_instancemethod(_enigma.iServiceInformationPtr_setInfoString, None, iServiceInformationPtr)
1072 iServiceInformationPtr_swigregister = _enigma.iServiceInformationPtr_swigregister
1073 iServiceInformationPtr_swigregister(iServiceInformationPtr)
1074
1075 class iFrontendInformation_ENUMS(object):
1076     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1077
1078     def __init__(self, *args, **kwargs):
1079         raise AttributeError("No constructor defined")
1080     __repr__ = _swig_repr
1081     bitErrorRate = _enigma.iFrontendInformation_ENUMS_bitErrorRate
1082     signalPower = _enigma.iFrontendInformation_ENUMS_signalPower
1083     signalQuality = _enigma.iFrontendInformation_ENUMS_signalQuality
1084     lockState = _enigma.iFrontendInformation_ENUMS_lockState
1085     syncState = _enigma.iFrontendInformation_ENUMS_syncState
1086     frontendNumber = _enigma.iFrontendInformation_ENUMS_frontendNumber
1087     signalQualitydB = _enigma.iFrontendInformation_ENUMS_signalQualitydB
1088     uncorrBlocks = _enigma.iFrontendInformation_ENUMS_uncorrBlocks
1089 iFrontendInformation_ENUMS_swigregister = _enigma.iFrontendInformation_ENUMS_swigregister
1090 iFrontendInformation_ENUMS_swigregister(iFrontendInformation_ENUMS)
1091
1092 iFrontendInformation = iFrontendInformation_ENUMS
1093 class iFrontendInformationPtr(object):
1094     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1095     __repr__ = _swig_repr
1096
1097     def __init__(self, *args):
1098         _enigma.iFrontendInformationPtr_swiginit(self, _enigma.new_iFrontendInformationPtr(*args))
1099     __swig_destroy__ = _enigma.delete_iFrontendInformationPtr
1100
1101     def getFrontendInfo(self, w):
1102         """getFrontendInfo(iFrontendInformationPtr self, int w) -> int"""
1103         return _enigma.iFrontendInformationPtr_getFrontendInfo(self, w)
1104
1105
1106     def getFrontendData(self):
1107         """getFrontendData(iFrontendInformationPtr self)"""
1108         return _enigma.iFrontendInformationPtr_getFrontendData(self)
1109
1110
1111     def getFrontendStatus(self):
1112         """getFrontendStatus(iFrontendInformationPtr self)"""
1113         return _enigma.iFrontendInformationPtr_getFrontendStatus(self)
1114
1115
1116     def getTransponderData(self, original):
1117         """getTransponderData(iFrontendInformationPtr self, bool original)"""
1118         return _enigma.iFrontendInformationPtr_getTransponderData(self, original)
1119
1120
1121     def getAll(self, original):
1122         """getAll(iFrontendInformationPtr self, bool original)"""
1123         return _enigma.iFrontendInformationPtr_getAll(self, original)
1124
1125 iFrontendInformationPtr.__ref__ = new_instancemethod(_enigma.iFrontendInformationPtr___ref__, None, iFrontendInformationPtr)
1126 iFrontendInformationPtr.getPtrString = new_instancemethod(_enigma.iFrontendInformationPtr_getPtrString, None, iFrontendInformationPtr)
1127 iFrontendInformationPtr.__deref__ = new_instancemethod(_enigma.iFrontendInformationPtr___deref__, None, iFrontendInformationPtr)
1128 iFrontendInformationPtr.getFrontendInfo = new_instancemethod(_enigma.iFrontendInformationPtr_getFrontendInfo, None, iFrontendInformationPtr)
1129 iFrontendInformationPtr.getFrontendData = new_instancemethod(_enigma.iFrontendInformationPtr_getFrontendData, None, iFrontendInformationPtr)
1130 iFrontendInformationPtr.getFrontendStatus = new_instancemethod(_enigma.iFrontendInformationPtr_getFrontendStatus, None, iFrontendInformationPtr)
1131 iFrontendInformationPtr.getTransponderData = new_instancemethod(_enigma.iFrontendInformationPtr_getTransponderData, None, iFrontendInformationPtr)
1132 iFrontendInformationPtr.getAll = new_instancemethod(_enigma.iFrontendInformationPtr_getAll, None, iFrontendInformationPtr)
1133 iFrontendInformationPtr_swigregister = _enigma.iFrontendInformationPtr_swigregister
1134 iFrontendInformationPtr_swigregister(iFrontendInformationPtr)
1135
1136 class iPauseableServicePtr(object):
1137     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1138     __repr__ = _swig_repr
1139
1140     def __init__(self, *args):
1141         _enigma.iPauseableServicePtr_swiginit(self, _enigma.new_iPauseableServicePtr(*args))
1142     __swig_destroy__ = _enigma.delete_iPauseableServicePtr
1143
1144     def pause(self):
1145         """pause(iPauseableServicePtr self) -> RESULT"""
1146         return _enigma.iPauseableServicePtr_pause(self)
1147
1148
1149     def unpause(self):
1150         """unpause(iPauseableServicePtr self) -> RESULT"""
1151         return _enigma.iPauseableServicePtr_unpause(self)
1152
1153
1154     def setSlowMotion(self, ratio=0):
1155         """
1156         setSlowMotion(iPauseableServicePtr self, int ratio=0) -> RESULT
1157         setSlowMotion(iPauseableServicePtr self) -> RESULT
1158         """
1159         return _enigma.iPauseableServicePtr_setSlowMotion(self, ratio)
1160
1161
1162     def setFastForward(self, ratio=0):
1163         """
1164         setFastForward(iPauseableServicePtr self, int ratio=0) -> RESULT
1165         setFastForward(iPauseableServicePtr self) -> RESULT
1166         """
1167         return _enigma.iPauseableServicePtr_setFastForward(self, ratio)
1168
1169 iPauseableServicePtr.__ref__ = new_instancemethod(_enigma.iPauseableServicePtr___ref__, None, iPauseableServicePtr)
1170 iPauseableServicePtr.getPtrString = new_instancemethod(_enigma.iPauseableServicePtr_getPtrString, None, iPauseableServicePtr)
1171 iPauseableServicePtr.__deref__ = new_instancemethod(_enigma.iPauseableServicePtr___deref__, None, iPauseableServicePtr)
1172 iPauseableServicePtr.pause = new_instancemethod(_enigma.iPauseableServicePtr_pause, None, iPauseableServicePtr)
1173 iPauseableServicePtr.unpause = new_instancemethod(_enigma.iPauseableServicePtr_unpause, None, iPauseableServicePtr)
1174 iPauseableServicePtr.setSlowMotion = new_instancemethod(_enigma.iPauseableServicePtr_setSlowMotion, None, iPauseableServicePtr)
1175 iPauseableServicePtr.setFastForward = new_instancemethod(_enigma.iPauseableServicePtr_setFastForward, None, iPauseableServicePtr)
1176 iPauseableServicePtr_swigregister = _enigma.iPauseableServicePtr_swigregister
1177 iPauseableServicePtr_swigregister(iPauseableServicePtr)
1178
1179 class iSeekableService_ENUMS(object):
1180     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1181
1182     def __init__(self, *args, **kwargs):
1183         raise AttributeError("No constructor defined")
1184     __repr__ = _swig_repr
1185     dirForward = _enigma.iSeekableService_ENUMS_dirForward
1186     dirBackward = _enigma.iSeekableService_ENUMS_dirBackward
1187 iSeekableService_ENUMS_swigregister = _enigma.iSeekableService_ENUMS_swigregister
1188 iSeekableService_ENUMS_swigregister(iSeekableService_ENUMS)
1189
1190 iSeekableService = iSeekableService_ENUMS
1191 class iSeekableServicePtr(object):
1192     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1193     __repr__ = _swig_repr
1194
1195     def __init__(self, *args):
1196         _enigma.iSeekableServicePtr_swiginit(self, _enigma.new_iSeekableServicePtr(*args))
1197     __swig_destroy__ = _enigma.delete_iSeekableServicePtr
1198
1199     def getLength(self):
1200         """getLength(iSeekableServicePtr self) -> RESULT"""
1201         return _enigma.iSeekableServicePtr_getLength(self)
1202
1203
1204     def seekTo(self, to):
1205         """seekTo(iSeekableServicePtr self, pts_t to) -> RESULT"""
1206         return _enigma.iSeekableServicePtr_seekTo(self, to)
1207
1208
1209     def seekRelative(self, direction, to):
1210         """seekRelative(iSeekableServicePtr self, int direction, pts_t to) -> RESULT"""
1211         return _enigma.iSeekableServicePtr_seekRelative(self, direction, to)
1212
1213
1214     def getPlayPosition(self):
1215         """getPlayPosition(iSeekableServicePtr self) -> RESULT"""
1216         return _enigma.iSeekableServicePtr_getPlayPosition(self)
1217
1218
1219     def setTrickmode(self, trick=0):
1220         """
1221         setTrickmode(iSeekableServicePtr self, int trick=0) -> RESULT
1222         setTrickmode(iSeekableServicePtr self) -> RESULT
1223         """
1224         return _enigma.iSeekableServicePtr_setTrickmode(self, trick)
1225
1226
1227     def isCurrentlySeekable(self):
1228         """isCurrentlySeekable(iSeekableServicePtr self) -> RESULT"""
1229         return _enigma.iSeekableServicePtr_isCurrentlySeekable(self)
1230
1231
1232     def seekChapter(self, arg2):
1233         """seekChapter(iSeekableServicePtr self, int arg2) -> RESULT"""
1234         return _enigma.iSeekableServicePtr_seekChapter(self, arg2)
1235
1236
1237     def seekTitle(self, arg2):
1238         """seekTitle(iSeekableServicePtr self, int arg2) -> RESULT"""
1239         return _enigma.iSeekableServicePtr_seekTitle(self, arg2)
1240
1241 iSeekableServicePtr.__ref__ = new_instancemethod(_enigma.iSeekableServicePtr___ref__, None, iSeekableServicePtr)
1242 iSeekableServicePtr.getPtrString = new_instancemethod(_enigma.iSeekableServicePtr_getPtrString, None, iSeekableServicePtr)
1243 iSeekableServicePtr.__deref__ = new_instancemethod(_enigma.iSeekableServicePtr___deref__, None, iSeekableServicePtr)
1244 iSeekableServicePtr.getLength = new_instancemethod(_enigma.iSeekableServicePtr_getLength, None, iSeekableServicePtr)
1245 iSeekableServicePtr.seekTo = new_instancemethod(_enigma.iSeekableServicePtr_seekTo, None, iSeekableServicePtr)
1246 iSeekableServicePtr.seekRelative = new_instancemethod(_enigma.iSeekableServicePtr_seekRelative, None, iSeekableServicePtr)
1247 iSeekableServicePtr.getPlayPosition = new_instancemethod(_enigma.iSeekableServicePtr_getPlayPosition, None, iSeekableServicePtr)
1248 iSeekableServicePtr.setTrickmode = new_instancemethod(_enigma.iSeekableServicePtr_setTrickmode, None, iSeekableServicePtr)
1249 iSeekableServicePtr.isCurrentlySeekable = new_instancemethod(_enigma.iSeekableServicePtr_isCurrentlySeekable, None, iSeekableServicePtr)
1250 iSeekableServicePtr.seekChapter = new_instancemethod(_enigma.iSeekableServicePtr_seekChapter, None, iSeekableServicePtr)
1251 iSeekableServicePtr.seekTitle = new_instancemethod(_enigma.iSeekableServicePtr_seekTitle, None, iSeekableServicePtr)
1252 iSeekableServicePtr_swigregister = _enigma.iSeekableServicePtr_swigregister
1253 iSeekableServicePtr_swigregister(iSeekableServicePtr)
1254
1255 class iAudioType_ENUMS(object):
1256     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1257
1258     def __init__(self, *args, **kwargs):
1259         raise AttributeError("No constructor defined")
1260     __repr__ = _swig_repr
1261     atMPEG = _enigma.iAudioType_ENUMS_atMPEG
1262     atAC3 = _enigma.iAudioType_ENUMS_atAC3
1263     atDTS = _enigma.iAudioType_ENUMS_atDTS
1264     atAAC = _enigma.iAudioType_ENUMS_atAAC
1265     atAACHE = _enigma.iAudioType_ENUMS_atAACHE
1266     atLPCM = _enigma.iAudioType_ENUMS_atLPCM
1267     atDTSHD = _enigma.iAudioType_ENUMS_atDTSHD
1268     atDDP = _enigma.iAudioType_ENUMS_atDDP
1269     atMP3 = _enigma.iAudioType_ENUMS_atMP3
1270     atPCM = _enigma.iAudioType_ENUMS_atPCM
1271     atOGG = _enigma.iAudioType_ENUMS_atOGG
1272     atFLAC = _enigma.iAudioType_ENUMS_atFLAC
1273     atWMA = _enigma.iAudioType_ENUMS_atWMA
1274     atTRUEHD = _enigma.iAudioType_ENUMS_atTRUEHD
1275     atUnknown = _enigma.iAudioType_ENUMS_atUnknown
1276 iAudioType_ENUMS_swigregister = _enigma.iAudioType_ENUMS_swigregister
1277 iAudioType_ENUMS_swigregister(iAudioType_ENUMS)
1278
1279 class iAudioTrackInfo(iAudioType_ENUMS):
1280     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1281
1282     def __init__(self, *args, **kwargs):
1283         raise AttributeError("No constructor defined")
1284     __repr__ = _swig_repr
1285     __swig_destroy__ = _enigma.delete_iAudioTrackInfo
1286
1287     def getDescription(self):
1288         """getDescription(iAudioTrackInfo self) -> std::string"""
1289         return _enigma.iAudioTrackInfo_getDescription(self)
1290
1291
1292     def getLanguage(self):
1293         """getLanguage(iAudioTrackInfo self) -> std::string"""
1294         return _enigma.iAudioTrackInfo_getLanguage(self)
1295
1296
1297     def getPID(self):
1298         """getPID(iAudioTrackInfo self) -> int"""
1299         return _enigma.iAudioTrackInfo_getPID(self)
1300
1301
1302     def getType(self):
1303         """getType(iAudioTrackInfo self) -> int"""
1304         return _enigma.iAudioTrackInfo_getType(self)
1305
1306
1307     def isSaved(self):
1308         """isSaved(iAudioTrackInfo self) -> int"""
1309         return _enigma.iAudioTrackInfo_isSaved(self)
1310
1311
1312     def isDefault(self):
1313         """isDefault(iAudioTrackInfo self) -> int"""
1314         return _enigma.iAudioTrackInfo_isDefault(self)
1315
1316
1317     def setLanguage(self, language):
1318         """setLanguage(iAudioTrackInfo self, std::string language)"""
1319         return _enigma.iAudioTrackInfo_setLanguage(self, language)
1320
1321
1322     def setDescription(self, description):
1323         """setDescription(iAudioTrackInfo self, std::string description)"""
1324         return _enigma.iAudioTrackInfo_setDescription(self, description)
1325
1326 iAudioTrackInfo.getDescription = new_instancemethod(_enigma.iAudioTrackInfo_getDescription, None, iAudioTrackInfo)
1327 iAudioTrackInfo.getLanguage = new_instancemethod(_enigma.iAudioTrackInfo_getLanguage, None, iAudioTrackInfo)
1328 iAudioTrackInfo.getPID = new_instancemethod(_enigma.iAudioTrackInfo_getPID, None, iAudioTrackInfo)
1329 iAudioTrackInfo.getType = new_instancemethod(_enigma.iAudioTrackInfo_getType, None, iAudioTrackInfo)
1330 iAudioTrackInfo.isSaved = new_instancemethod(_enigma.iAudioTrackInfo_isSaved, None, iAudioTrackInfo)
1331 iAudioTrackInfo.isDefault = new_instancemethod(_enigma.iAudioTrackInfo_isDefault, None, iAudioTrackInfo)
1332 iAudioTrackInfo.setLanguage = new_instancemethod(_enigma.iAudioTrackInfo_setLanguage, None, iAudioTrackInfo)
1333 iAudioTrackInfo.setDescription = new_instancemethod(_enigma.iAudioTrackInfo_setDescription, None, iAudioTrackInfo)
1334 iAudioTrackInfo_swigregister = _enigma.iAudioTrackInfo_swigregister
1335 iAudioTrackInfo_swigregister(iAudioTrackInfo)
1336
1337 class iAudioTrackSelectionPtr(object):
1338     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1339     __repr__ = _swig_repr
1340
1341     def __init__(self, *args):
1342         _enigma.iAudioTrackSelectionPtr_swiginit(self, _enigma.new_iAudioTrackSelectionPtr(*args))
1343     __swig_destroy__ = _enigma.delete_iAudioTrackSelectionPtr
1344
1345     def getNumberOfTracks(self):
1346         """getNumberOfTracks(iAudioTrackSelectionPtr self) -> int"""
1347         return _enigma.iAudioTrackSelectionPtr_getNumberOfTracks(self)
1348
1349
1350     def selectTrack(self, i):
1351         """selectTrack(iAudioTrackSelectionPtr self, unsigned int i) -> RESULT"""
1352         return _enigma.iAudioTrackSelectionPtr_selectTrack(self, i)
1353
1354
1355     def getTrackInfo(self, n):
1356         """getTrackInfo(iAudioTrackSelectionPtr self, unsigned int n)"""
1357         return _enigma.iAudioTrackSelectionPtr_getTrackInfo(self, n)
1358
1359
1360     def getCurrentTrack(self):
1361         """getCurrentTrack(iAudioTrackSelectionPtr self) -> int"""
1362         return _enigma.iAudioTrackSelectionPtr_getCurrentTrack(self)
1363
1364 iAudioTrackSelectionPtr.__ref__ = new_instancemethod(_enigma.iAudioTrackSelectionPtr___ref__, None, iAudioTrackSelectionPtr)
1365 iAudioTrackSelectionPtr.getPtrString = new_instancemethod(_enigma.iAudioTrackSelectionPtr_getPtrString, None, iAudioTrackSelectionPtr)
1366 iAudioTrackSelectionPtr.__deref__ = new_instancemethod(_enigma.iAudioTrackSelectionPtr___deref__, None, iAudioTrackSelectionPtr)
1367 iAudioTrackSelectionPtr.getNumberOfTracks = new_instancemethod(_enigma.iAudioTrackSelectionPtr_getNumberOfTracks, None, iAudioTrackSelectionPtr)
1368 iAudioTrackSelectionPtr.selectTrack = new_instancemethod(_enigma.iAudioTrackSelectionPtr_selectTrack, None, iAudioTrackSelectionPtr)
1369 iAudioTrackSelectionPtr.getTrackInfo = new_instancemethod(_enigma.iAudioTrackSelectionPtr_getTrackInfo, None, iAudioTrackSelectionPtr)
1370 iAudioTrackSelectionPtr.getCurrentTrack = new_instancemethod(_enigma.iAudioTrackSelectionPtr_getCurrentTrack, None, iAudioTrackSelectionPtr)
1371 iAudioTrackSelectionPtr_swigregister = _enigma.iAudioTrackSelectionPtr_swigregister
1372 iAudioTrackSelectionPtr_swigregister(iAudioTrackSelectionPtr)
1373
1374 class iAudioChannelSelection_ENUMS(object):
1375     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1376
1377     def __init__(self, *args, **kwargs):
1378         raise AttributeError("No constructor defined")
1379     __repr__ = _swig_repr
1380     LEFT = _enigma.iAudioChannelSelection_ENUMS_LEFT
1381     STEREO = _enigma.iAudioChannelSelection_ENUMS_STEREO
1382     RIGHT = _enigma.iAudioChannelSelection_ENUMS_RIGHT
1383 iAudioChannelSelection_ENUMS_swigregister = _enigma.iAudioChannelSelection_ENUMS_swigregister
1384 iAudioChannelSelection_ENUMS_swigregister(iAudioChannelSelection_ENUMS)
1385
1386 iAudioChannelSelection = iAudioChannelSelection_ENUMS
1387 class iAudioChannelSelectionPtr(object):
1388     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1389     __repr__ = _swig_repr
1390
1391     def __init__(self, *args):
1392         _enigma.iAudioChannelSelectionPtr_swiginit(self, _enigma.new_iAudioChannelSelectionPtr(*args))
1393     __swig_destroy__ = _enigma.delete_iAudioChannelSelectionPtr
1394
1395     def getCurrentChannel(self):
1396         """getCurrentChannel(iAudioChannelSelectionPtr self) -> int"""
1397         return _enigma.iAudioChannelSelectionPtr_getCurrentChannel(self)
1398
1399
1400     def selectChannel(self, i):
1401         """selectChannel(iAudioChannelSelectionPtr self, int i) -> RESULT"""
1402         return _enigma.iAudioChannelSelectionPtr_selectChannel(self, i)
1403
1404 iAudioChannelSelectionPtr.__ref__ = new_instancemethod(_enigma.iAudioChannelSelectionPtr___ref__, None, iAudioChannelSelectionPtr)
1405 iAudioChannelSelectionPtr.getPtrString = new_instancemethod(_enigma.iAudioChannelSelectionPtr_getPtrString, None, iAudioChannelSelectionPtr)
1406 iAudioChannelSelectionPtr.__deref__ = new_instancemethod(_enigma.iAudioChannelSelectionPtr___deref__, None, iAudioChannelSelectionPtr)
1407 iAudioChannelSelectionPtr.getCurrentChannel = new_instancemethod(_enigma.iAudioChannelSelectionPtr_getCurrentChannel, None, iAudioChannelSelectionPtr)
1408 iAudioChannelSelectionPtr.selectChannel = new_instancemethod(_enigma.iAudioChannelSelectionPtr_selectChannel, None, iAudioChannelSelectionPtr)
1409 iAudioChannelSelectionPtr_swigregister = _enigma.iAudioChannelSelectionPtr_swigregister
1410 iAudioChannelSelectionPtr_swigregister(iAudioChannelSelectionPtr)
1411
1412 class iAudioDelayPtr(object):
1413     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1414     __repr__ = _swig_repr
1415
1416     def __init__(self, *args):
1417         _enigma.iAudioDelayPtr_swiginit(self, _enigma.new_iAudioDelayPtr(*args))
1418     __swig_destroy__ = _enigma.delete_iAudioDelayPtr
1419
1420     def getAC3Delay(self):
1421         """getAC3Delay(iAudioDelayPtr self) -> int"""
1422         return _enigma.iAudioDelayPtr_getAC3Delay(self)
1423
1424
1425     def getPCMDelay(self):
1426         """getPCMDelay(iAudioDelayPtr self) -> int"""
1427         return _enigma.iAudioDelayPtr_getPCMDelay(self)
1428
1429
1430     def setAC3Delay(self, arg2):
1431         """setAC3Delay(iAudioDelayPtr self, int arg2)"""
1432         return _enigma.iAudioDelayPtr_setAC3Delay(self, arg2)
1433
1434
1435     def setPCMDelay(self, arg2):
1436         """setPCMDelay(iAudioDelayPtr self, int arg2)"""
1437         return _enigma.iAudioDelayPtr_setPCMDelay(self, arg2)
1438
1439 iAudioDelayPtr.__ref__ = new_instancemethod(_enigma.iAudioDelayPtr___ref__, None, iAudioDelayPtr)
1440 iAudioDelayPtr.getPtrString = new_instancemethod(_enigma.iAudioDelayPtr_getPtrString, None, iAudioDelayPtr)
1441 iAudioDelayPtr.__deref__ = new_instancemethod(_enigma.iAudioDelayPtr___deref__, None, iAudioDelayPtr)
1442 iAudioDelayPtr.getAC3Delay = new_instancemethod(_enigma.iAudioDelayPtr_getAC3Delay, None, iAudioDelayPtr)
1443 iAudioDelayPtr.getPCMDelay = new_instancemethod(_enigma.iAudioDelayPtr_getPCMDelay, None, iAudioDelayPtr)
1444 iAudioDelayPtr.setAC3Delay = new_instancemethod(_enigma.iAudioDelayPtr_setAC3Delay, None, iAudioDelayPtr)
1445 iAudioDelayPtr.setPCMDelay = new_instancemethod(_enigma.iAudioDelayPtr_setPCMDelay, None, iAudioDelayPtr)
1446 iAudioDelayPtr_swigregister = _enigma.iAudioDelayPtr_swigregister
1447 iAudioDelayPtr_swigregister(iAudioDelayPtr)
1448
1449 class iRdsDecoder_ENUMS(object):
1450     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1451
1452     def __init__(self, *args, **kwargs):
1453         raise AttributeError("No constructor defined")
1454     __repr__ = _swig_repr
1455     RadioText = _enigma.iRdsDecoder_ENUMS_RadioText
1456     RtpText = _enigma.iRdsDecoder_ENUMS_RtpText
1457 iRdsDecoder_ENUMS_swigregister = _enigma.iRdsDecoder_ENUMS_swigregister
1458 iRdsDecoder_ENUMS_swigregister(iRdsDecoder_ENUMS)
1459
1460 iRdsDecoder = iRdsDecoder_ENUMS
1461 class iRdsDecoderPtr(object):
1462     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1463     __repr__ = _swig_repr
1464
1465     def __init__(self, *args):
1466         _enigma.iRdsDecoderPtr_swiginit(self, _enigma.new_iRdsDecoderPtr(*args))
1467     __swig_destroy__ = _enigma.delete_iRdsDecoderPtr
1468
1469     def getText(self, *args):
1470         """
1471         getText(iRdsDecoderPtr self, int x) -> std::string
1472         getText(iRdsDecoderPtr self) -> std::string
1473         """
1474         return _enigma.iRdsDecoderPtr_getText(self, *args)
1475
1476
1477     def showRassSlidePicture(self):
1478         """showRassSlidePicture(iRdsDecoderPtr self)"""
1479         return _enigma.iRdsDecoderPtr_showRassSlidePicture(self)
1480
1481
1482     def showRassInteractivePic(self, page, subpage):
1483         """showRassInteractivePic(iRdsDecoderPtr self, int page, int subpage)"""
1484         return _enigma.iRdsDecoderPtr_showRassInteractivePic(self, page, subpage)
1485
1486
1487     def getRassInteractiveMask(self):
1488         """getRassInteractiveMask(iRdsDecoderPtr self) -> unsigned char const *"""
1489         return _enigma.iRdsDecoderPtr_getRassInteractiveMask(self)
1490
1491 iRdsDecoderPtr.__ref__ = new_instancemethod(_enigma.iRdsDecoderPtr___ref__, None, iRdsDecoderPtr)
1492 iRdsDecoderPtr.getPtrString = new_instancemethod(_enigma.iRdsDecoderPtr_getPtrString, None, iRdsDecoderPtr)
1493 iRdsDecoderPtr.__deref__ = new_instancemethod(_enigma.iRdsDecoderPtr___deref__, None, iRdsDecoderPtr)
1494 iRdsDecoderPtr.getText = new_instancemethod(_enigma.iRdsDecoderPtr_getText, None, iRdsDecoderPtr)
1495 iRdsDecoderPtr.showRassSlidePicture = new_instancemethod(_enigma.iRdsDecoderPtr_showRassSlidePicture, None, iRdsDecoderPtr)
1496 iRdsDecoderPtr.showRassInteractivePic = new_instancemethod(_enigma.iRdsDecoderPtr_showRassInteractivePic, None, iRdsDecoderPtr)
1497 iRdsDecoderPtr.getRassInteractiveMask = new_instancemethod(_enigma.iRdsDecoderPtr_getRassInteractiveMask, None, iRdsDecoderPtr)
1498 iRdsDecoderPtr_swigregister = _enigma.iRdsDecoderPtr_swigregister
1499 iRdsDecoderPtr_swigregister(iRdsDecoderPtr)
1500
1501 class iSubserviceListPtr(object):
1502     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1503     __repr__ = _swig_repr
1504
1505     def __init__(self, *args):
1506         _enigma.iSubserviceListPtr_swiginit(self, _enigma.new_iSubserviceListPtr(*args))
1507     __swig_destroy__ = _enigma.delete_iSubserviceListPtr
1508
1509     def getNumberOfSubservices(self):
1510         """getNumberOfSubservices(iSubserviceListPtr self) -> int"""
1511         return _enigma.iSubserviceListPtr_getNumberOfSubservices(self)
1512
1513
1514     def getSubservice(self, n):
1515         """getSubservice(iSubserviceListPtr self, unsigned int n)"""
1516         return _enigma.iSubserviceListPtr_getSubservice(self, n)
1517
1518 iSubserviceListPtr.__ref__ = new_instancemethod(_enigma.iSubserviceListPtr___ref__, None, iSubserviceListPtr)
1519 iSubserviceListPtr.getPtrString = new_instancemethod(_enigma.iSubserviceListPtr_getPtrString, None, iSubserviceListPtr)
1520 iSubserviceListPtr.__deref__ = new_instancemethod(_enigma.iSubserviceListPtr___deref__, None, iSubserviceListPtr)
1521 iSubserviceListPtr.getNumberOfSubservices = new_instancemethod(_enigma.iSubserviceListPtr_getNumberOfSubservices, None, iSubserviceListPtr)
1522 iSubserviceListPtr.getSubservice = new_instancemethod(_enigma.iSubserviceListPtr_getSubservice, None, iSubserviceListPtr)
1523 iSubserviceListPtr_swigregister = _enigma.iSubserviceListPtr_swigregister
1524 iSubserviceListPtr_swigregister(iSubserviceListPtr)
1525
1526 class iTimeshiftServicePtr(object):
1527     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1528     __repr__ = _swig_repr
1529
1530     def __init__(self, *args):
1531         _enigma.iTimeshiftServicePtr_swiginit(self, _enigma.new_iTimeshiftServicePtr(*args))
1532     __swig_destroy__ = _enigma.delete_iTimeshiftServicePtr
1533
1534     def startTimeshift(self):
1535         """startTimeshift(iTimeshiftServicePtr self) -> RESULT"""
1536         return _enigma.iTimeshiftServicePtr_startTimeshift(self)
1537
1538
1539     def stopTimeshift(self, mode=1):
1540         """
1541         stopTimeshift(iTimeshiftServicePtr self, int mode=1) -> RESULT
1542         stopTimeshift(iTimeshiftServicePtr self) -> RESULT
1543         """
1544         return _enigma.iTimeshiftServicePtr_stopTimeshift(self, mode)
1545
1546
1547     def setNextPlaybackFile(self, fn):
1548         """setNextPlaybackFile(iTimeshiftServicePtr self, char const * fn) -> RESULT"""
1549         return _enigma.iTimeshiftServicePtr_setNextPlaybackFile(self, fn)
1550
1551
1552     def setPrevPlaybackFile(self, fn):
1553         """setPrevPlaybackFile(iTimeshiftServicePtr self, char const * fn) -> RESULT"""
1554         return _enigma.iTimeshiftServicePtr_setPrevPlaybackFile(self, fn)
1555
1556
1557     def isTimeshiftActive(self):
1558         """isTimeshiftActive(iTimeshiftServicePtr self) -> int"""
1559         return _enigma.iTimeshiftServicePtr_isTimeshiftActive(self)
1560
1561
1562     def activateTimeshift(self):
1563         """activateTimeshift(iTimeshiftServicePtr self) -> RESULT"""
1564         return _enigma.iTimeshiftServicePtr_activateTimeshift(self)
1565
1566 iTimeshiftServicePtr.__ref__ = new_instancemethod(_enigma.iTimeshiftServicePtr___ref__, None, iTimeshiftServicePtr)
1567 iTimeshiftServicePtr.getPtrString = new_instancemethod(_enigma.iTimeshiftServicePtr_getPtrString, None, iTimeshiftServicePtr)
1568 iTimeshiftServicePtr.__deref__ = new_instancemethod(_enigma.iTimeshiftServicePtr___deref__, None, iTimeshiftServicePtr)
1569 iTimeshiftServicePtr.startTimeshift = new_instancemethod(_enigma.iTimeshiftServicePtr_startTimeshift, None, iTimeshiftServicePtr)
1570 iTimeshiftServicePtr.stopTimeshift = new_instancemethod(_enigma.iTimeshiftServicePtr_stopTimeshift, None, iTimeshiftServicePtr)
1571 iTimeshiftServicePtr.setNextPlaybackFile = new_instancemethod(_enigma.iTimeshiftServicePtr_setNextPlaybackFile, None, iTimeshiftServicePtr)
1572 iTimeshiftServicePtr.setPrevPlaybackFile = new_instancemethod(_enigma.iTimeshiftServicePtr_setPrevPlaybackFile, None, iTimeshiftServicePtr)
1573 iTimeshiftServicePtr.isTimeshiftActive = new_instancemethod(_enigma.iTimeshiftServicePtr_isTimeshiftActive, None, iTimeshiftServicePtr)
1574 iTimeshiftServicePtr.activateTimeshift = new_instancemethod(_enigma.iTimeshiftServicePtr_activateTimeshift, None, iTimeshiftServicePtr)
1575 iTimeshiftServicePtr_swigregister = _enigma.iTimeshiftServicePtr_swigregister
1576 iTimeshiftServicePtr_swigregister(iTimeshiftServicePtr)
1577
1578 class iCueSheet_ENUMS(object):
1579     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1580
1581     def __init__(self, *args, **kwargs):
1582         raise AttributeError("No constructor defined")
1583     __repr__ = _swig_repr
1584     cutIn = _enigma.iCueSheet_ENUMS_cutIn
1585     cutOut = _enigma.iCueSheet_ENUMS_cutOut
1586     cutMark = _enigma.iCueSheet_ENUMS_cutMark
1587 iCueSheet_ENUMS_swigregister = _enigma.iCueSheet_ENUMS_swigregister
1588 iCueSheet_ENUMS_swigregister(iCueSheet_ENUMS)
1589
1590 iCueSheet = iCueSheet_ENUMS
1591 class iCueSheetPtr(object):
1592     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1593     __repr__ = _swig_repr
1594
1595     def __init__(self, *args):
1596         _enigma.iCueSheetPtr_swiginit(self, _enigma.new_iCueSheetPtr(*args))
1597     __swig_destroy__ = _enigma.delete_iCueSheetPtr
1598
1599     def getCutList(self):
1600         """getCutList(iCueSheetPtr self) -> std::list< std::pair< pts_t,unsigned int >,std::allocator< std::pair< pts_t,unsigned int > > >"""
1601         return _enigma.iCueSheetPtr_getCutList(self)
1602
1603
1604     def setCutList(self, list):
1605         """setCutList(iCueSheetPtr self, std::list< std::pair< pts_t,unsigned int >,std::allocator< std::pair< pts_t,unsigned int > > > list)"""
1606         return _enigma.iCueSheetPtr_setCutList(self, list)
1607
1608
1609     def setCutListEnable(self, enable):
1610         """setCutListEnable(iCueSheetPtr self, int enable)"""
1611         return _enigma.iCueSheetPtr_setCutListEnable(self, enable)
1612
1613 iCueSheetPtr.__ref__ = new_instancemethod(_enigma.iCueSheetPtr___ref__, None, iCueSheetPtr)
1614 iCueSheetPtr.getPtrString = new_instancemethod(_enigma.iCueSheetPtr_getPtrString, None, iCueSheetPtr)
1615 iCueSheetPtr.__deref__ = new_instancemethod(_enigma.iCueSheetPtr___deref__, None, iCueSheetPtr)
1616 iCueSheetPtr.getCutList = new_instancemethod(_enigma.iCueSheetPtr_getCutList, None, iCueSheetPtr)
1617 iCueSheetPtr.setCutList = new_instancemethod(_enigma.iCueSheetPtr_setCutList, None, iCueSheetPtr)
1618 iCueSheetPtr.setCutListEnable = new_instancemethod(_enigma.iCueSheetPtr_setCutListEnable, None, iCueSheetPtr)
1619 iCueSheetPtr_swigregister = _enigma.iCueSheetPtr_swigregister
1620 iCueSheetPtr_swigregister(iCueSheetPtr)
1621
1622 class iSubtitleType_ENUMS(object):
1623     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1624
1625     def __init__(self, *args, **kwargs):
1626         raise AttributeError("No constructor defined")
1627     __repr__ = _swig_repr
1628     NONE = _enigma.iSubtitleType_ENUMS_NONE
1629     DVB = _enigma.iSubtitleType_ENUMS_DVB
1630     TTX = _enigma.iSubtitleType_ENUMS_TTX
1631     DVD = _enigma.iSubtitleType_ENUMS_DVD
1632     GST = _enigma.iSubtitleType_ENUMS_GST
1633     TXT = _enigma.iSubtitleType_ENUMS_TXT
1634 iSubtitleType_ENUMS_swigregister = _enigma.iSubtitleType_ENUMS_swigregister
1635 iSubtitleType_ENUMS_swigregister(iSubtitleType_ENUMS)
1636
1637 class iGstSubtitleType_ENUMS(object):
1638     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1639
1640     def __init__(self, *args, **kwargs):
1641         raise AttributeError("No constructor defined")
1642     __repr__ = _swig_repr
1643     stUnknown = _enigma.iGstSubtitleType_ENUMS_stUnknown
1644     stPlainText = _enigma.iGstSubtitleType_ENUMS_stPlainText
1645     stSSA = _enigma.iGstSubtitleType_ENUMS_stSSA
1646     stASS = _enigma.iGstSubtitleType_ENUMS_stASS
1647     stVOB = _enigma.iGstSubtitleType_ENUMS_stVOB
1648     stPGS = _enigma.iGstSubtitleType_ENUMS_stPGS
1649 iGstSubtitleType_ENUMS_swigregister = _enigma.iGstSubtitleType_ENUMS_swigregister
1650 iGstSubtitleType_ENUMS_swigregister(iGstSubtitleType_ENUMS)
1651
1652 class iSubtitleFilterType_ENUMS(object):
1653     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1654
1655     def __init__(self, *args, **kwargs):
1656         raise AttributeError("No constructor defined")
1657     __repr__ = _swig_repr
1658     SUB_FILTER_NONE = _enigma.iSubtitleFilterType_ENUMS_SUB_FILTER_NONE
1659     SUB_FILTER_SHOW_FORCED_ONLY = _enigma.iSubtitleFilterType_ENUMS_SUB_FILTER_SHOW_FORCED_ONLY
1660     SUB_FILTER_SHOW_ALL = _enigma.iSubtitleFilterType_ENUMS_SUB_FILTER_SHOW_ALL
1661 iSubtitleFilterType_ENUMS_swigregister = _enigma.iSubtitleFilterType_ENUMS_swigregister
1662 iSubtitleFilterType_ENUMS_swigregister(iSubtitleFilterType_ENUMS)
1663
1664 class iSubtitleTrackInfo(iSubtitleType_ENUMS, iGstSubtitleType_ENUMS):
1665     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1666
1667     def __init__(self, *args, **kwargs):
1668         raise AttributeError("No constructor defined")
1669     __repr__ = _swig_repr
1670     __swig_destroy__ = _enigma.delete_iSubtitleTrackInfo
1671
1672     def getType(self):
1673         """getType(iSubtitleTrackInfo self) -> int"""
1674         return _enigma.iSubtitleTrackInfo_getType(self)
1675
1676
1677     def getPID(self):
1678         """getPID(iSubtitleTrackInfo self) -> int"""
1679         return _enigma.iSubtitleTrackInfo_getPID(self)
1680
1681
1682     def getLanguage(self):
1683         """getLanguage(iSubtitleTrackInfo self) -> std::string"""
1684         return _enigma.iSubtitleTrackInfo_getLanguage(self)
1685
1686
1687     def getCompositionPageID(self):
1688         """getCompositionPageID(iSubtitleTrackInfo self) -> int"""
1689         return _enigma.iSubtitleTrackInfo_getCompositionPageID(self)
1690
1691
1692     def getAncillaryPageID(self):
1693         """getAncillaryPageID(iSubtitleTrackInfo self) -> int"""
1694         return _enigma.iSubtitleTrackInfo_getAncillaryPageID(self)
1695
1696
1697     def getPageNumber(self):
1698         """getPageNumber(iSubtitleTrackInfo self) -> int"""
1699         return _enigma.iSubtitleTrackInfo_getPageNumber(self)
1700
1701
1702     def getMagazineNumber(self):
1703         """getMagazineNumber(iSubtitleTrackInfo self) -> int"""
1704         return _enigma.iSubtitleTrackInfo_getMagazineNumber(self)
1705
1706
1707     def getGstSubtype(self):
1708         """getGstSubtype(iSubtitleTrackInfo self) -> int"""
1709         return _enigma.iSubtitleTrackInfo_getGstSubtype(self)
1710
1711
1712     def isSaved(self):
1713         """isSaved(iSubtitleTrackInfo self) -> int"""
1714         return _enigma.iSubtitleTrackInfo_isSaved(self)
1715
1716
1717     def isDefault(self):
1718         """isDefault(iSubtitleTrackInfo self) -> int"""
1719         return _enigma.iSubtitleTrackInfo_isDefault(self)
1720
1721
1722     def isForced(self):
1723         """isForced(iSubtitleTrackInfo self) -> int"""
1724         return _enigma.iSubtitleTrackInfo_isForced(self)
1725
1726
1727     def getFilter(self):
1728         """getFilter(iSubtitleTrackInfo self) -> int"""
1729         return _enigma.iSubtitleTrackInfo_getFilter(self)
1730
1731
1732     def setLanguage(self, language):
1733         """setLanguage(iSubtitleTrackInfo self, std::string language)"""
1734         return _enigma.iSubtitleTrackInfo_setLanguage(self, language)
1735
1736
1737     def setFilter(self, filter):
1738         """setFilter(iSubtitleTrackInfo self, int filter)"""
1739         return _enigma.iSubtitleTrackInfo_setFilter(self, filter)
1740
1741
1742     def setGstSubtype(self, gst_subtype):
1743         """setGstSubtype(iSubtitleTrackInfo self, int gst_subtype)"""
1744         return _enigma.iSubtitleTrackInfo_setGstSubtype(self, gst_subtype)
1745
1746 iSubtitleTrackInfo.getType = new_instancemethod(_enigma.iSubtitleTrackInfo_getType, None, iSubtitleTrackInfo)
1747 iSubtitleTrackInfo.getPID = new_instancemethod(_enigma.iSubtitleTrackInfo_getPID, None, iSubtitleTrackInfo)
1748 iSubtitleTrackInfo.getLanguage = new_instancemethod(_enigma.iSubtitleTrackInfo_getLanguage, None, iSubtitleTrackInfo)
1749 iSubtitleTrackInfo.getCompositionPageID = new_instancemethod(_enigma.iSubtitleTrackInfo_getCompositionPageID, None, iSubtitleTrackInfo)
1750 iSubtitleTrackInfo.getAncillaryPageID = new_instancemethod(_enigma.iSubtitleTrackInfo_getAncillaryPageID, None, iSubtitleTrackInfo)
1751 iSubtitleTrackInfo.getPageNumber = new_instancemethod(_enigma.iSubtitleTrackInfo_getPageNumber, None, iSubtitleTrackInfo)
1752 iSubtitleTrackInfo.getMagazineNumber = new_instancemethod(_enigma.iSubtitleTrackInfo_getMagazineNumber, None, iSubtitleTrackInfo)
1753 iSubtitleTrackInfo.getGstSubtype = new_instancemethod(_enigma.iSubtitleTrackInfo_getGstSubtype, None, iSubtitleTrackInfo)
1754 iSubtitleTrackInfo.isSaved = new_instancemethod(_enigma.iSubtitleTrackInfo_isSaved, None, iSubtitleTrackInfo)
1755 iSubtitleTrackInfo.isDefault = new_instancemethod(_enigma.iSubtitleTrackInfo_isDefault, None, iSubtitleTrackInfo)
1756 iSubtitleTrackInfo.isForced = new_instancemethod(_enigma.iSubtitleTrackInfo_isForced, None, iSubtitleTrackInfo)
1757 iSubtitleTrackInfo.getFilter = new_instancemethod(_enigma.iSubtitleTrackInfo_getFilter, None, iSubtitleTrackInfo)
1758 iSubtitleTrackInfo.setLanguage = new_instancemethod(_enigma.iSubtitleTrackInfo_setLanguage, None, iSubtitleTrackInfo)
1759 iSubtitleTrackInfo.setFilter = new_instancemethod(_enigma.iSubtitleTrackInfo_setFilter, None, iSubtitleTrackInfo)
1760 iSubtitleTrackInfo.setGstSubtype = new_instancemethod(_enigma.iSubtitleTrackInfo_setGstSubtype, None, iSubtitleTrackInfo)
1761 iSubtitleTrackInfo_swigregister = _enigma.iSubtitleTrackInfo_swigregister
1762 iSubtitleTrackInfo_swigregister(iSubtitleTrackInfo)
1763
1764 class iSubtitleTrackSelectionPtr(object):
1765     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1766     __repr__ = _swig_repr
1767
1768     def __init__(self, *args):
1769         _enigma.iSubtitleTrackSelectionPtr_swiginit(self, _enigma.new_iSubtitleTrackSelectionPtr(*args))
1770     __swig_destroy__ = _enigma.delete_iSubtitleTrackSelectionPtr
1771
1772     def getNumberOfSubtitleTracks(self):
1773         """getNumberOfSubtitleTracks(iSubtitleTrackSelectionPtr self) -> int"""
1774         return _enigma.iSubtitleTrackSelectionPtr_getNumberOfSubtitleTracks(self)
1775
1776
1777     def getSubtitleTrackInfo(self, n):
1778         """getSubtitleTrackInfo(iSubtitleTrackSelectionPtr self, unsigned int n)"""
1779         return _enigma.iSubtitleTrackSelectionPtr_getSubtitleTrackInfo(self, n)
1780
1781
1782     def getCurrentSubtitleTrack(self):
1783         """getCurrentSubtitleTrack(iSubtitleTrackSelectionPtr self) -> int"""
1784         return _enigma.iSubtitleTrackSelectionPtr_getCurrentSubtitleTrack(self)
1785
1786
1787     def enableSubtitles(self, parent, i):
1788         """enableSubtitles(iSubtitleTrackSelectionPtr self, eWidget parent, unsigned int i) -> RESULT"""
1789         return _enigma.iSubtitleTrackSelectionPtr_enableSubtitles(self, parent, i)
1790
1791
1792     def disableSubtitles(self, parent):
1793         """disableSubtitles(iSubtitleTrackSelectionPtr self, eWidget parent) -> RESULT"""
1794         return _enigma.iSubtitleTrackSelectionPtr_disableSubtitles(self, parent)
1795
1796 iSubtitleTrackSelectionPtr.__ref__ = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr___ref__, None, iSubtitleTrackSelectionPtr)
1797 iSubtitleTrackSelectionPtr.getPtrString = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_getPtrString, None, iSubtitleTrackSelectionPtr)
1798 iSubtitleTrackSelectionPtr.__deref__ = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr___deref__, None, iSubtitleTrackSelectionPtr)
1799 iSubtitleTrackSelectionPtr.getNumberOfSubtitleTracks = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_getNumberOfSubtitleTracks, None, iSubtitleTrackSelectionPtr)
1800 iSubtitleTrackSelectionPtr.getSubtitleTrackInfo = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_getSubtitleTrackInfo, None, iSubtitleTrackSelectionPtr)
1801 iSubtitleTrackSelectionPtr.getCurrentSubtitleTrack = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_getCurrentSubtitleTrack, None, iSubtitleTrackSelectionPtr)
1802 iSubtitleTrackSelectionPtr.enableSubtitles = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_enableSubtitles, None, iSubtitleTrackSelectionPtr)
1803 iSubtitleTrackSelectionPtr.disableSubtitles = new_instancemethod(_enigma.iSubtitleTrackSelectionPtr_disableSubtitles, None, iSubtitleTrackSelectionPtr)
1804 iSubtitleTrackSelectionPtr_swigregister = _enigma.iSubtitleTrackSelectionPtr_swigregister
1805 iSubtitleTrackSelectionPtr_swigregister(iSubtitleTrackSelectionPtr)
1806
1807 class iMutableServiceListPtr(object):
1808     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1809     __repr__ = _swig_repr
1810
1811     def __init__(self, *args):
1812         _enigma.iMutableServiceListPtr_swiginit(self, _enigma.new_iMutableServiceListPtr(*args))
1813     __swig_destroy__ = _enigma.delete_iMutableServiceListPtr
1814
1815     def flushChanges(self):
1816         """flushChanges(iMutableServiceListPtr self) -> RESULT"""
1817         return _enigma.iMutableServiceListPtr_flushChanges(self)
1818
1819
1820     def addService(self, *args):
1821         """
1822         addService(iMutableServiceListPtr self, eServiceReference ref, eServiceReference before) -> RESULT
1823         addService(iMutableServiceListPtr self, eServiceReference ref) -> RESULT
1824         """
1825         return _enigma.iMutableServiceListPtr_addService(self, *args)
1826
1827
1828     def removeService(self, ref):
1829         """removeService(iMutableServiceListPtr self, eServiceReference ref) -> RESULT"""
1830         return _enigma.iMutableServiceListPtr_removeService(self, ref)
1831
1832
1833     def moveService(self, ref, pos):
1834         """moveService(iMutableServiceListPtr self, eServiceReference ref, int pos) -> RESULT"""
1835         return _enigma.iMutableServiceListPtr_moveService(self, ref, pos)
1836
1837
1838     def setListName(self, name):
1839         """setListName(iMutableServiceListPtr self, std::string const & name) -> RESULT"""
1840         return _enigma.iMutableServiceListPtr_setListName(self, name)
1841
1842 iMutableServiceListPtr.__ref__ = new_instancemethod(_enigma.iMutableServiceListPtr___ref__, None, iMutableServiceListPtr)
1843 iMutableServiceListPtr.getPtrString = new_instancemethod(_enigma.iMutableServiceListPtr_getPtrString, None, iMutableServiceListPtr)
1844 iMutableServiceListPtr.__deref__ = new_instancemethod(_enigma.iMutableServiceListPtr___deref__, None, iMutableServiceListPtr)
1845 iMutableServiceListPtr.flushChanges = new_instancemethod(_enigma.iMutableServiceListPtr_flushChanges, None, iMutableServiceListPtr)
1846 iMutableServiceListPtr.addService = new_instancemethod(_enigma.iMutableServiceListPtr_addService, None, iMutableServiceListPtr)
1847 iMutableServiceListPtr.removeService = new_instancemethod(_enigma.iMutableServiceListPtr_removeService, None, iMutableServiceListPtr)
1848 iMutableServiceListPtr.moveService = new_instancemethod(_enigma.iMutableServiceListPtr_moveService, None, iMutableServiceListPtr)
1849 iMutableServiceListPtr.setListName = new_instancemethod(_enigma.iMutableServiceListPtr_setListName, None, iMutableServiceListPtr)
1850 iMutableServiceListPtr_swigregister = _enigma.iMutableServiceListPtr_swigregister
1851 iMutableServiceListPtr_swigregister(iMutableServiceListPtr)
1852
1853 class iListableServicePtr(object):
1854     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1855     __repr__ = _swig_repr
1856
1857     def __init__(self, *args):
1858         _enigma.iListableServicePtr_swiginit(self, _enigma.new_iListableServicePtr(*args))
1859     __swig_destroy__ = _enigma.delete_iListableServicePtr
1860
1861     def getContent(self, format, sorted=False):
1862         """
1863         getContent(iListableServicePtr self, char const * format, bool sorted=False) -> PyObject
1864         getContent(iListableServicePtr self, char const * format) -> PyObject *
1865         """
1866         return _enigma.iListableServicePtr_getContent(self, format, sorted)
1867
1868
1869     def getNext(self):
1870         """getNext(iListableServicePtr self)"""
1871         return _enigma.iListableServicePtr_getNext(self)
1872
1873
1874     def compareLessEqual(self, arg2, arg3):
1875         """compareLessEqual(iListableServicePtr self, eServiceReference arg2, eServiceReference arg3) -> int"""
1876         return _enigma.iListableServicePtr_compareLessEqual(self, arg2, arg3)
1877
1878
1879     def startEdit(self):
1880         """startEdit(iListableServicePtr self)"""
1881         return _enigma.iListableServicePtr_startEdit(self)
1882
1883 iListableServicePtr.__ref__ = new_instancemethod(_enigma.iListableServicePtr___ref__, None, iListableServicePtr)
1884 iListableServicePtr.getPtrString = new_instancemethod(_enigma.iListableServicePtr_getPtrString, None, iListableServicePtr)
1885 iListableServicePtr.__deref__ = new_instancemethod(_enigma.iListableServicePtr___deref__, None, iListableServicePtr)
1886 iListableServicePtr.getContent = new_instancemethod(_enigma.iListableServicePtr_getContent, None, iListableServicePtr)
1887 iListableServicePtr.getNext = new_instancemethod(_enigma.iListableServicePtr_getNext, None, iListableServicePtr)
1888 iListableServicePtr.compareLessEqual = new_instancemethod(_enigma.iListableServicePtr_compareLessEqual, None, iListableServicePtr)
1889 iListableServicePtr.startEdit = new_instancemethod(_enigma.iListableServicePtr_startEdit, None, iListableServicePtr)
1890 iListableServicePtr_swigregister = _enigma.iListableServicePtr_swigregister
1891 iListableServicePtr_swigregister(iListableServicePtr)
1892
1893 class iServiceOfflineOperationsPtr(object):
1894     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1895     __repr__ = _swig_repr
1896
1897     def __init__(self, *args):
1898         _enigma.iServiceOfflineOperationsPtr_swiginit(self, _enigma.new_iServiceOfflineOperationsPtr(*args))
1899     __swig_destroy__ = _enigma.delete_iServiceOfflineOperationsPtr
1900
1901     def deleteFromDisk(self, simulate=1):
1902         """
1903         deleteFromDisk(iServiceOfflineOperationsPtr self, int simulate=1) -> RESULT
1904         deleteFromDisk(iServiceOfflineOperationsPtr self) -> RESULT
1905         """
1906         return _enigma.iServiceOfflineOperationsPtr_deleteFromDisk(self, simulate)
1907
1908
1909     def getListOfFilenames(self, OUTPUT):
1910         """getListOfFilenames(iServiceOfflineOperationsPtr self, StringList OUTPUT)"""
1911         return _enigma.iServiceOfflineOperationsPtr_getListOfFilenames(self, OUTPUT)
1912
1913
1914     def reindex(self):
1915         """reindex(iServiceOfflineOperationsPtr self) -> int"""
1916         return _enigma.iServiceOfflineOperationsPtr_reindex(self)
1917
1918 iServiceOfflineOperationsPtr.__ref__ = new_instancemethod(_enigma.iServiceOfflineOperationsPtr___ref__, None, iServiceOfflineOperationsPtr)
1919 iServiceOfflineOperationsPtr.getPtrString = new_instancemethod(_enigma.iServiceOfflineOperationsPtr_getPtrString, None, iServiceOfflineOperationsPtr)
1920 iServiceOfflineOperationsPtr.__deref__ = new_instancemethod(_enigma.iServiceOfflineOperationsPtr___deref__, None, iServiceOfflineOperationsPtr)
1921 iServiceOfflineOperationsPtr.deleteFromDisk = new_instancemethod(_enigma.iServiceOfflineOperationsPtr_deleteFromDisk, None, iServiceOfflineOperationsPtr)
1922 iServiceOfflineOperationsPtr.getListOfFilenames = new_instancemethod(_enigma.iServiceOfflineOperationsPtr_getListOfFilenames, None, iServiceOfflineOperationsPtr)
1923 iServiceOfflineOperationsPtr.reindex = new_instancemethod(_enigma.iServiceOfflineOperationsPtr_reindex, None, iServiceOfflineOperationsPtr)
1924 iServiceOfflineOperationsPtr_swigregister = _enigma.iServiceOfflineOperationsPtr_swigregister
1925 iServiceOfflineOperationsPtr_swigregister(iServiceOfflineOperationsPtr)
1926
1927 class iStreamableServicePtr(object):
1928     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1929     __repr__ = _swig_repr
1930
1931     def __init__(self, *args):
1932         _enigma.iStreamableServicePtr_swiginit(self, _enigma.new_iStreamableServicePtr(*args))
1933     __swig_destroy__ = _enigma.delete_iStreamableServicePtr
1934
1935     def getStreamingData(self, includeEit=True):
1936         """
1937         getStreamingData(iStreamableServicePtr self, bool includeEit=True) -> PseudoDict
1938         getStreamingData(iStreamableServicePtr self) -> PseudoDict
1939         """
1940         return _enigma.iStreamableServicePtr_getStreamingData(self, includeEit)
1941
1942 iStreamableServicePtr.__ref__ = new_instancemethod(_enigma.iStreamableServicePtr___ref__, None, iStreamableServicePtr)
1943 iStreamableServicePtr.getPtrString = new_instancemethod(_enigma.iStreamableServicePtr_getPtrString, None, iStreamableServicePtr)
1944 iStreamableServicePtr.__deref__ = new_instancemethod(_enigma.iStreamableServicePtr___deref__, None, iStreamableServicePtr)
1945 iStreamableServicePtr.getStreamingData = new_instancemethod(_enigma.iStreamableServicePtr_getStreamingData, None, iStreamableServicePtr)
1946 iStreamableServicePtr_swigregister = _enigma.iStreamableServicePtr_swigregister
1947 iStreamableServicePtr_swigregister(iStreamableServicePtr)
1948
1949 class iStreamedServicePtr(object):
1950     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1951     __repr__ = _swig_repr
1952
1953     def __init__(self, *args):
1954         _enigma.iStreamedServicePtr_swiginit(self, _enigma.new_iStreamedServicePtr(*args))
1955     __swig_destroy__ = _enigma.delete_iStreamedServicePtr
1956
1957     def getBufferCharge(self):
1958         """getBufferCharge(iStreamedServicePtr self) -> IntList"""
1959         return _enigma.iStreamedServicePtr_getBufferCharge(self)
1960
1961
1962     def setBufferSize(self, size):
1963         """setBufferSize(iStreamedServicePtr self, int size) -> int"""
1964         return _enigma.iStreamedServicePtr_setBufferSize(self, size)
1965
1966
1967     def setBufferDuration(self, ms):
1968         """setBufferDuration(iStreamedServicePtr self, int ms) -> int"""
1969         return _enigma.iStreamedServicePtr_setBufferDuration(self, ms)
1970
1971
1972     def setTransportHeaders(self, headers):
1973         """setTransportHeaders(iStreamedServicePtr self, StringMap headers)"""
1974         return _enigma.iStreamedServicePtr_setTransportHeaders(self, headers)
1975
1976 iStreamedServicePtr.__ref__ = new_instancemethod(_enigma.iStreamedServicePtr___ref__, None, iStreamedServicePtr)
1977 iStreamedServicePtr.getPtrString = new_instancemethod(_enigma.iStreamedServicePtr_getPtrString, None, iStreamedServicePtr)
1978 iStreamedServicePtr.__deref__ = new_instancemethod(_enigma.iStreamedServicePtr___deref__, None, iStreamedServicePtr)
1979 iStreamedServicePtr.getBufferCharge = new_instancemethod(_enigma.iStreamedServicePtr_getBufferCharge, None, iStreamedServicePtr)
1980 iStreamedServicePtr.setBufferSize = new_instancemethod(_enigma.iStreamedServicePtr_setBufferSize, None, iStreamedServicePtr)
1981 iStreamedServicePtr.setBufferDuration = new_instancemethod(_enigma.iStreamedServicePtr_setBufferDuration, None, iStreamedServicePtr)
1982 iStreamedServicePtr.setTransportHeaders = new_instancemethod(_enigma.iStreamedServicePtr_setTransportHeaders, None, iStreamedServicePtr)
1983 iStreamedServicePtr_swigregister = _enigma.iStreamedServicePtr_swigregister
1984 iStreamedServicePtr_swigregister(iStreamedServicePtr)
1985
1986 class iUriService(iObject):
1987     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1988
1989     def __init__(self, *args, **kwargs):
1990         raise AttributeError("No constructor defined - class is abstract")
1991     __repr__ = _swig_repr
1992
1993     def setResolvedName(self, name):
1994         """setResolvedName(iUriService self, std::string const & name)"""
1995         return _enigma.iUriService_setResolvedName(self, name)
1996
1997
1998     def setResolvedUri(self, *args):
1999         """
2000         setResolvedUri(iUriService self, std::string const & resolvedUri, int serviceType, std::string const & suburi)
2001         setResolvedUri(iUriService self, std::string const & resolvedUri, int serviceType)
2002         """
2003         return _enigma.iUriService_setResolvedUri(self, *args)
2004
2005
2006     def failedToResolveUri(self):
2007         """failedToResolveUri(iUriService self)"""
2008         return _enigma.iUriService_failedToResolveUri(self)
2009
2010 iUriService.setResolvedName = new_instancemethod(_enigma.iUriService_setResolvedName, None, iUriService)
2011 iUriService.setResolvedUri = new_instancemethod(_enigma.iUriService_setResolvedUri, None, iUriService)
2012 iUriService.failedToResolveUri = new_instancemethod(_enigma.iUriService_failedToResolveUri, None, iUriService)
2013 iUriService_swigregister = _enigma.iUriService_swigregister
2014 iUriService_swigregister(iUriService)
2015
2016 class iUriServicePtr(object):
2017     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2018     __repr__ = _swig_repr
2019
2020     def __init__(self, *args):
2021         _enigma.iUriServicePtr_swiginit(self, _enigma.new_iUriServicePtr(*args))
2022     __swig_destroy__ = _enigma.delete_iUriServicePtr
2023
2024     def setResolvedName(self, name):
2025         """setResolvedName(iUriServicePtr self, std::string const & name)"""
2026         return _enigma.iUriServicePtr_setResolvedName(self, name)
2027
2028
2029     def setResolvedUri(self, *args):
2030         """
2031         setResolvedUri(iUriServicePtr self, std::string const & resolvedUri, int serviceType, std::string const & suburi)
2032         setResolvedUri(iUriServicePtr self, std::string const & resolvedUri, int serviceType)
2033         """
2034         return _enigma.iUriServicePtr_setResolvedUri(self, *args)
2035
2036
2037     def failedToResolveUri(self):
2038         """failedToResolveUri(iUriServicePtr self)"""
2039         return _enigma.iUriServicePtr_failedToResolveUri(self)
2040
2041 iUriServicePtr.__ref__ = new_instancemethod(_enigma.iUriServicePtr___ref__, None, iUriServicePtr)
2042 iUriServicePtr.getPtrString = new_instancemethod(_enigma.iUriServicePtr_getPtrString, None, iUriServicePtr)
2043 iUriServicePtr.__deref__ = new_instancemethod(_enigma.iUriServicePtr___deref__, None, iUriServicePtr)
2044 iUriServicePtr.setResolvedName = new_instancemethod(_enigma.iUriServicePtr_setResolvedName, None, iUriServicePtr)
2045 iUriServicePtr.setResolvedUri = new_instancemethod(_enigma.iUriServicePtr_setResolvedUri, None, iUriServicePtr)
2046 iUriServicePtr.failedToResolveUri = new_instancemethod(_enigma.iUriServicePtr_failedToResolveUri, None, iUriServicePtr)
2047 iUriServicePtr_swigregister = _enigma.iUriServicePtr_swigregister
2048 iUriServicePtr_swigregister(iUriServicePtr)
2049
2050 class iServiceKeys_ENUMS(object):
2051     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2052
2053     def __init__(self, *args, **kwargs):
2054         raise AttributeError("No constructor defined")
2055     __repr__ = _swig_repr
2056     keyLeft = _enigma.iServiceKeys_ENUMS_keyLeft
2057     keyRight = _enigma.iServiceKeys_ENUMS_keyRight
2058     keyUp = _enigma.iServiceKeys_ENUMS_keyUp
2059     keyDown = _enigma.iServiceKeys_ENUMS_keyDown
2060     keyOk = _enigma.iServiceKeys_ENUMS_keyOk
2061     keyUser = _enigma.iServiceKeys_ENUMS_keyUser
2062 iServiceKeys_ENUMS_swigregister = _enigma.iServiceKeys_ENUMS_swigregister
2063 iServiceKeys_ENUMS_swigregister(iServiceKeys_ENUMS)
2064
2065 iServiceKeys = iServiceKeys_ENUMS
2066 class iServiceKeysPtr(object):
2067     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2068     __repr__ = _swig_repr
2069
2070     def __init__(self, *args):
2071         _enigma.iServiceKeysPtr_swiginit(self, _enigma.new_iServiceKeysPtr(*args))
2072     __swig_destroy__ = _enigma.delete_iServiceKeysPtr
2073
2074     def keyPressed(self, key):
2075         """keyPressed(iServiceKeysPtr self, int key)"""
2076         return _enigma.iServiceKeysPtr_keyPressed(self, key)
2077
2078 iServiceKeysPtr.__ref__ = new_instancemethod(_enigma.iServiceKeysPtr___ref__, None, iServiceKeysPtr)
2079 iServiceKeysPtr.getPtrString = new_instancemethod(_enigma.iServiceKeysPtr_getPtrString, None, iServiceKeysPtr)
2080 iServiceKeysPtr.__deref__ = new_instancemethod(_enigma.iServiceKeysPtr___deref__, None, iServiceKeysPtr)
2081 iServiceKeysPtr.keyPressed = new_instancemethod(_enigma.iServiceKeysPtr_keyPressed, None, iServiceKeysPtr)
2082 iServiceKeysPtr_swigregister = _enigma.iServiceKeysPtr_swigregister
2083 iServiceKeysPtr_swigregister(iServiceKeysPtr)
2084
2085 class iHbbtvPtr(object):
2086     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2087     __repr__ = _swig_repr
2088
2089     def __init__(self, *args):
2090         _enigma.iHbbtvPtr_swiginit(self, _enigma.new_iHbbtvPtr(*args))
2091     __swig_destroy__ = _enigma.delete_iHbbtvPtr
2092 iHbbtvPtr.__ref__ = new_instancemethod(_enigma.iHbbtvPtr___ref__, None, iHbbtvPtr)
2093 iHbbtvPtr.getPtrString = new_instancemethod(_enigma.iHbbtvPtr_getPtrString, None, iHbbtvPtr)
2094 iHbbtvPtr.__deref__ = new_instancemethod(_enigma.iHbbtvPtr___deref__, None, iHbbtvPtr)
2095 iHbbtvPtr_swigregister = _enigma.iHbbtvPtr_swigregister
2096 iHbbtvPtr_swigregister(iHbbtvPtr)
2097
2098 class iPlayableService_ENUMS(object):
2099     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2100
2101     def __init__(self, *args, **kwargs):
2102         raise AttributeError("No constructor defined")
2103     __repr__ = _swig_repr
2104     evStart = _enigma.iPlayableService_ENUMS_evStart
2105     evEnd = _enigma.iPlayableService_ENUMS_evEnd
2106     evTunedIn = _enigma.iPlayableService_ENUMS_evTunedIn
2107     evTuneFailed = _enigma.iPlayableService_ENUMS_evTuneFailed
2108     evUpdatedEventInfo = _enigma.iPlayableService_ENUMS_evUpdatedEventInfo
2109     evUpdatedInfo = _enigma.iPlayableService_ENUMS_evUpdatedInfo
2110     evSeekableStatusChanged = _enigma.iPlayableService_ENUMS_evSeekableStatusChanged
2111     evEOF = _enigma.iPlayableService_ENUMS_evEOF
2112     evSOF = _enigma.iPlayableService_ENUMS_evSOF
2113     evCuesheetChanged = _enigma.iPlayableService_ENUMS_evCuesheetChanged
2114     evUpdatedRadioText = _enigma.iPlayableService_ENUMS_evUpdatedRadioText
2115     evUpdatedRtpText = _enigma.iPlayableService_ENUMS_evUpdatedRtpText
2116     evUpdatedRassSlidePic = _enigma.iPlayableService_ENUMS_evUpdatedRassSlidePic
2117     evUpdatedRassInteractivePicMask = _enigma.iPlayableService_ENUMS_evUpdatedRassInteractivePicMask
2118     evVideoTypeReady = _enigma.iPlayableService_ENUMS_evVideoTypeReady
2119     evVideoSizeChanged = _enigma.iPlayableService_ENUMS_evVideoSizeChanged
2120     evVideoFramerateChanged = _enigma.iPlayableService_ENUMS_evVideoFramerateChanged
2121     evVideoProgressiveChanged = _enigma.iPlayableService_ENUMS_evVideoProgressiveChanged
2122     evVideoPtsValid = _enigma.iPlayableService_ENUMS_evVideoPtsValid
2123     evBuffering = _enigma.iPlayableService_ENUMS_evBuffering
2124     evStopped = _enigma.iPlayableService_ENUMS_evStopped
2125     evSubtitleListChanged = _enigma.iPlayableService_ENUMS_evSubtitleListChanged
2126     evAudioListChanged = _enigma.iPlayableService_ENUMS_evAudioListChanged
2127     evPause = _enigma.iPlayableService_ENUMS_evPause
2128     evPlay = _enigma.iPlayableService_ENUMS_evPlay
2129     evSeek = _enigma.iPlayableService_ENUMS_evSeek
2130     evNotFound = _enigma.iPlayableService_ENUMS_evNotFound
2131     evServiceChanged = _enigma.iPlayableService_ENUMS_evServiceChanged
2132     evUser = _enigma.iPlayableService_ENUMS_evUser
2133     stateIdle = _enigma.iPlayableService_ENUMS_stateIdle
2134     stateStop = _enigma.iPlayableService_ENUMS_stateStop
2135     statePlay = _enigma.iPlayableService_ENUMS_statePlay
2136     statePause = _enigma.iPlayableService_ENUMS_statePause
2137     stateBuffering = _enigma.iPlayableService_ENUMS_stateBuffering
2138     stateSeek = _enigma.iPlayableService_ENUMS_stateSeek
2139 iPlayableService_ENUMS_swigregister = _enigma.iPlayableService_ENUMS_swigregister
2140 iPlayableService_ENUMS_swigregister(iPlayableService_ENUMS)
2141
2142 iPlayableService = iPlayableService_ENUMS
2143 class iPlayableServicePtr(object):
2144     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2145     __repr__ = _swig_repr
2146
2147     def __init__(self, *args):
2148         _enigma.iPlayableServicePtr_swiginit(self, _enigma.new_iPlayableServicePtr(*args))
2149     __swig_destroy__ = _enigma.delete_iPlayableServicePtr
2150
2151     def start(self):
2152         """start(iPlayableServicePtr self) -> RESULT"""
2153         return _enigma.iPlayableServicePtr_start(self)
2154
2155
2156     def stop(self):
2157         """stop(iPlayableServicePtr self) -> RESULT"""
2158         return _enigma.iPlayableServicePtr_stop(self)
2159
2160
2161     def playState(self):
2162         """playState(iPlayableServicePtr self) -> int"""
2163         return _enigma.iPlayableServicePtr_playState(self)
2164
2165
2166     def setTarget(self, target):
2167         """setTarget(iPlayableServicePtr self, int target) -> RESULT"""
2168         return _enigma.iPlayableServicePtr_setTarget(self, target)
2169
2170
2171     def seek(self):
2172         """seek(iPlayableServicePtr self)"""
2173         return _enigma.iPlayableServicePtr_seek(self)
2174
2175
2176     def pause(self):
2177         """pause(iPlayableServicePtr self)"""
2178         return _enigma.iPlayableServicePtr_pause(self)
2179
2180
2181     def info(self):
2182         """info(iPlayableServicePtr self)"""
2183         return _enigma.iPlayableServicePtr_info(self)
2184
2185
2186     def audioTracks(self):
2187         """audioTracks(iPlayableServicePtr self)"""
2188         return _enigma.iPlayableServicePtr_audioTracks(self)
2189
2190
2191     def audioChannel(self):
2192         """audioChannel(iPlayableServicePtr self)"""
2193         return _enigma.iPlayableServicePtr_audioChannel(self)
2194
2195
2196     def subServices(self):
2197         """subServices(iPlayableServicePtr self)"""
2198         return _enigma.iPlayableServicePtr_subServices(self)
2199
2200
2201     def frontendInfo(self):
2202         """frontendInfo(iPlayableServicePtr self)"""
2203         return _enigma.iPlayableServicePtr_frontendInfo(self)
2204
2205
2206     def timeshift(self):
2207         """timeshift(iPlayableServicePtr self)"""
2208         return _enigma.iPlayableServicePtr_timeshift(self)
2209
2210
2211     def cueSheet(self):
2212         """cueSheet(iPlayableServicePtr self)"""
2213         return _enigma.iPlayableServicePtr_cueSheet(self)
2214
2215
2216     def subtitleTracks(self):
2217         """subtitleTracks(iPlayableServicePtr self)"""
2218         return _enigma.iPlayableServicePtr_subtitleTracks(self)
2219
2220
2221     def audioDelay(self):
2222         """audioDelay(iPlayableServicePtr self)"""
2223         return _enigma.iPlayableServicePtr_audioDelay(self)
2224
2225
2226     def rdsDecoder(self):
2227         """rdsDecoder(iPlayableServicePtr self)"""
2228         return _enigma.iPlayableServicePtr_rdsDecoder(self)
2229
2230
2231     def stream(self):
2232         """stream(iPlayableServicePtr self)"""
2233         return _enigma.iPlayableServicePtr_stream(self)
2234
2235
2236     def streamed(self):
2237         """streamed(iPlayableServicePtr self)"""
2238         return _enigma.iPlayableServicePtr_streamed(self)
2239
2240
2241     def keys(self):
2242         """keys(iPlayableServicePtr self)"""
2243         return _enigma.iPlayableServicePtr_keys(self)
2244
2245
2246     def hbbtv(self):
2247         """hbbtv(iPlayableServicePtr self)"""
2248         return _enigma.iPlayableServicePtr_hbbtv(self)
2249
2250 iPlayableServicePtr.__ref__ = new_instancemethod(_enigma.iPlayableServicePtr___ref__, None, iPlayableServicePtr)
2251 iPlayableServicePtr.getPtrString = new_instancemethod(_enigma.iPlayableServicePtr_getPtrString, None, iPlayableServicePtr)
2252 iPlayableServicePtr.__deref__ = new_instancemethod(_enigma.iPlayableServicePtr___deref__, None, iPlayableServicePtr)
2253 iPlayableServicePtr.start = new_instancemethod(_enigma.iPlayableServicePtr_start, None, iPlayableServicePtr)
2254 iPlayableServicePtr.stop = new_instancemethod(_enigma.iPlayableServicePtr_stop, None, iPlayableServicePtr)
2255 iPlayableServicePtr.playState = new_instancemethod(_enigma.iPlayableServicePtr_playState, None, iPlayableServicePtr)
2256 iPlayableServicePtr.setTarget = new_instancemethod(_enigma.iPlayableServicePtr_setTarget, None, iPlayableServicePtr)
2257 iPlayableServicePtr.seek = new_instancemethod(_enigma.iPlayableServicePtr_seek, None, iPlayableServicePtr)
2258 iPlayableServicePtr.pause = new_instancemethod(_enigma.iPlayableServicePtr_pause, None, iPlayableServicePtr)
2259 iPlayableServicePtr.info = new_instancemethod(_enigma.iPlayableServicePtr_info, None, iPlayableServicePtr)
2260 iPlayableServicePtr.audioTracks = new_instancemethod(_enigma.iPlayableServicePtr_audioTracks, None, iPlayableServicePtr)
2261 iPlayableServicePtr.audioChannel = new_instancemethod(_enigma.iPlayableServicePtr_audioChannel, None, iPlayableServicePtr)
2262 iPlayableServicePtr.subServices = new_instancemethod(_enigma.iPlayableServicePtr_subServices, None, iPlayableServicePtr)
2263 iPlayableServicePtr.frontendInfo = new_instancemethod(_enigma.iPlayableServicePtr_frontendInfo, None, iPlayableServicePtr)
2264 iPlayableServicePtr.timeshift = new_instancemethod(_enigma.iPlayableServicePtr_timeshift, None, iPlayableServicePtr)
2265 iPlayableServicePtr.cueSheet = new_instancemethod(_enigma.iPlayableServicePtr_cueSheet, None, iPlayableServicePtr)
2266 iPlayableServicePtr.subtitleTracks = new_instancemethod(_enigma.iPlayableServicePtr_subtitleTracks, None, iPlayableServicePtr)
2267 iPlayableServicePtr.audioDelay = new_instancemethod(_enigma.iPlayableServicePtr_audioDelay, None, iPlayableServicePtr)
2268 iPlayableServicePtr.rdsDecoder = new_instancemethod(_enigma.iPlayableServicePtr_rdsDecoder, None, iPlayableServicePtr)
2269 iPlayableServicePtr.stream = new_instancemethod(_enigma.iPlayableServicePtr_stream, None, iPlayableServicePtr)
2270 iPlayableServicePtr.streamed = new_instancemethod(_enigma.iPlayableServicePtr_streamed, None, iPlayableServicePtr)
2271 iPlayableServicePtr.keys = new_instancemethod(_enigma.iPlayableServicePtr_keys, None, iPlayableServicePtr)
2272 iPlayableServicePtr.hbbtv = new_instancemethod(_enigma.iPlayableServicePtr_hbbtv, None, iPlayableServicePtr)
2273 iPlayableServicePtr_swigregister = _enigma.iPlayableServicePtr_swigregister
2274 iPlayableServicePtr_swigregister(iPlayableServicePtr)
2275
2276 class iRecordableService_ENUMS(object):
2277     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2278
2279     def __init__(self, *args, **kwargs):
2280         raise AttributeError("No constructor defined")
2281     __repr__ = _swig_repr
2282     evStart = _enigma.iRecordableService_ENUMS_evStart
2283     evEnd = _enigma.iRecordableService_ENUMS_evEnd
2284     evTunedIn = _enigma.iRecordableService_ENUMS_evTunedIn
2285     evTuneFailed = _enigma.iRecordableService_ENUMS_evTuneFailed
2286     evRecordRunning = _enigma.iRecordableService_ENUMS_evRecordRunning
2287     evRecordStopped = _enigma.iRecordableService_ENUMS_evRecordStopped
2288     evNewProgramInfo = _enigma.iRecordableService_ENUMS_evNewProgramInfo
2289     evRecordFailed = _enigma.iRecordableService_ENUMS_evRecordFailed
2290     evRecordWriteError = _enigma.iRecordableService_ENUMS_evRecordWriteError
2291     evNewEventInfo = _enigma.iRecordableService_ENUMS_evNewEventInfo
2292     evGstRecordEOS = _enigma.iRecordableService_ENUMS_evGstRecordEOS
2293     NoError = _enigma.iRecordableService_ENUMS_NoError
2294     errOpenRecordFile = _enigma.iRecordableService_ENUMS_errOpenRecordFile
2295     errNoDemuxAvailable = _enigma.iRecordableService_ENUMS_errNoDemuxAvailable
2296     errNoTsRecorderAvailable = _enigma.iRecordableService_ENUMS_errNoTsRecorderAvailable
2297     errDiskFull = _enigma.iRecordableService_ENUMS_errDiskFull
2298     errTuneFailed = _enigma.iRecordableService_ENUMS_errTuneFailed
2299     errMisconfiguration = _enigma.iRecordableService_ENUMS_errMisconfiguration
2300     errNoResources = _enigma.iRecordableService_ENUMS_errNoResources
2301 iRecordableService_ENUMS_swigregister = _enigma.iRecordableService_ENUMS_swigregister
2302 iRecordableService_ENUMS_swigregister(iRecordableService_ENUMS)
2303
2304 iRecordableService = iRecordableService_ENUMS
2305 class iRecordableServicePtr(object):
2306     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2307     __repr__ = _swig_repr
2308
2309     def __init__(self, *args):
2310         _enigma.iRecordableServicePtr_swiginit(self, _enigma.new_iRecordableServicePtr(*args))
2311     __swig_destroy__ = _enigma.delete_iRecordableServicePtr
2312
2313     def getError(self):
2314         """getError(iRecordableServicePtr self)"""
2315         return _enigma.iRecordableServicePtr_getError(self)
2316
2317
2318     def prepare(self, filename, begTime=-1, endTime=-1, eit_event_id=-1, name=None, descr=None, tags=None):
2319         """
2320         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
2321         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
2322         prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1, char const * name=None) -> RESULT
2323         prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1) -> RESULT
2324         prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1, time_t endTime=-1) -> RESULT
2325         prepare(iRecordableServicePtr self, char const * filename, time_t begTime=-1) -> RESULT
2326         prepare(iRecordableServicePtr self, char const * filename) -> RESULT
2327         """
2328         return _enigma.iRecordableServicePtr_prepare(self, filename, begTime, endTime, eit_event_id, name, descr, tags)
2329
2330
2331     def prepareStreaming(self):
2332         """prepareStreaming(iRecordableServicePtr self) -> RESULT"""
2333         return _enigma.iRecordableServicePtr_prepareStreaming(self)
2334
2335
2336     def start(self, simulate=False):
2337         """
2338         start(iRecordableServicePtr self, bool simulate=False) -> RESULT
2339         start(iRecordableServicePtr self) -> RESULT
2340         """
2341         return _enigma.iRecordableServicePtr_start(self, simulate)
2342
2343
2344     def stop(self):
2345         """stop(iRecordableServicePtr self) -> RESULT"""
2346         return _enigma.iRecordableServicePtr_stop(self)
2347
2348
2349     def frontendInfo(self):
2350         """frontendInfo(iRecordableServicePtr self)"""
2351         return _enigma.iRecordableServicePtr_frontendInfo(self)
2352
2353
2354     def stream(self):
2355         """stream(iRecordableServicePtr self)"""
2356         return _enigma.iRecordableServicePtr_stream(self)
2357
2358
2359     def subServices(self):
2360         """subServices(iRecordableServicePtr self)"""
2361         return _enigma.iRecordableServicePtr_subServices(self)
2362
2363
2364     def getFileExtension(self):
2365         """getFileExtension(iRecordableServicePtr self)"""
2366         return _enigma.iRecordableServicePtr_getFileExtension(self)
2367
2368 iRecordableServicePtr.__ref__ = new_instancemethod(_enigma.iRecordableServicePtr___ref__, None, iRecordableServicePtr)
2369 iRecordableServicePtr.getPtrString = new_instancemethod(_enigma.iRecordableServicePtr_getPtrString, None, iRecordableServicePtr)
2370 iRecordableServicePtr.__deref__ = new_instancemethod(_enigma.iRecordableServicePtr___deref__, None, iRecordableServicePtr)
2371 iRecordableServicePtr.getError = new_instancemethod(_enigma.iRecordableServicePtr_getError, None, iRecordableServicePtr)
2372 iRecordableServicePtr.prepare = new_instancemethod(_enigma.iRecordableServicePtr_prepare, None, iRecordableServicePtr)
2373 iRecordableServicePtr.prepareStreaming = new_instancemethod(_enigma.iRecordableServicePtr_prepareStreaming, None, iRecordableServicePtr)
2374 iRecordableServicePtr.start = new_instancemethod(_enigma.iRecordableServicePtr_start, None, iRecordableServicePtr)
2375 iRecordableServicePtr.stop = new_instancemethod(_enigma.iRecordableServicePtr_stop, None, iRecordableServicePtr)
2376 iRecordableServicePtr.frontendInfo = new_instancemethod(_enigma.iRecordableServicePtr_frontendInfo, None, iRecordableServicePtr)
2377 iRecordableServicePtr.stream = new_instancemethod(_enigma.iRecordableServicePtr_stream, None, iRecordableServicePtr)
2378 iRecordableServicePtr.subServices = new_instancemethod(_enigma.iRecordableServicePtr_subServices, None, iRecordableServicePtr)
2379 iRecordableServicePtr.getFileExtension = new_instancemethod(_enigma.iRecordableServicePtr_getFileExtension, None, iRecordableServicePtr)
2380 iRecordableServicePtr_swigregister = _enigma.iRecordableServicePtr_swigregister
2381 iRecordableServicePtr_swigregister(iRecordableServicePtr)
2382
2383
2384 def New_iRecordableServicePtr(ref):
2385     return _enigma.New_iRecordableServicePtr(ref)
2386 New_iRecordableServicePtr = _enigma.New_iRecordableServicePtr
2387 class iServiceHandlerPtr(object):
2388     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2389     __repr__ = _swig_repr
2390
2391     def __init__(self, *args):
2392         _enigma.iServiceHandlerPtr_swiginit(self, _enigma.new_iServiceHandlerPtr(*args))
2393     __swig_destroy__ = _enigma.delete_iServiceHandlerPtr
2394
2395     def play(self, arg2):
2396         """play(iServiceHandlerPtr self, eServiceReference arg2)"""
2397         return _enigma.iServiceHandlerPtr_play(self, arg2)
2398
2399
2400     def record(self, arg2):
2401         """record(iServiceHandlerPtr self, eServiceReference arg2)"""
2402         return _enigma.iServiceHandlerPtr_record(self, arg2)
2403
2404
2405     def list(self, arg2):
2406         """list(iServiceHandlerPtr self, eServiceReference arg2)"""
2407         return _enigma.iServiceHandlerPtr_list(self, arg2)
2408
2409
2410     def info(self, arg2):
2411         """info(iServiceHandlerPtr self, eServiceReference arg2)"""
2412         return _enigma.iServiceHandlerPtr_info(self, arg2)
2413
2414
2415     def offlineOperations(self, arg2):
2416         """offlineOperations(iServiceHandlerPtr self, eServiceReference arg2)"""
2417         return _enigma.iServiceHandlerPtr_offlineOperations(self, arg2)
2418
2419 iServiceHandlerPtr.__ref__ = new_instancemethod(_enigma.iServiceHandlerPtr___ref__, None, iServiceHandlerPtr)
2420 iServiceHandlerPtr.getPtrString = new_instancemethod(_enigma.iServiceHandlerPtr_getPtrString, None, iServiceHandlerPtr)
2421 iServiceHandlerPtr.__deref__ = new_instancemethod(_enigma.iServiceHandlerPtr___deref__, None, iServiceHandlerPtr)
2422 iServiceHandlerPtr.play = new_instancemethod(_enigma.iServiceHandlerPtr_play, None, iServiceHandlerPtr)
2423 iServiceHandlerPtr.record = new_instancemethod(_enigma.iServiceHandlerPtr_record, None, iServiceHandlerPtr)
2424 iServiceHandlerPtr.list = new_instancemethod(_enigma.iServiceHandlerPtr_list, None, iServiceHandlerPtr)
2425 iServiceHandlerPtr.info = new_instancemethod(_enigma.iServiceHandlerPtr_info, None, iServiceHandlerPtr)
2426 iServiceHandlerPtr.offlineOperations = new_instancemethod(_enigma.iServiceHandlerPtr_offlineOperations, None, iServiceHandlerPtr)
2427 iServiceHandlerPtr_swigregister = _enigma.iServiceHandlerPtr_swigregister
2428 iServiceHandlerPtr_swigregister(iServiceHandlerPtr)
2429
2430 class eServiceCenter(object):
2431     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2432
2433     def __init__(self, *args, **kwargs):
2434         raise AttributeError("No constructor defined - class is abstract")
2435     __repr__ = _swig_repr
2436
2437     def getInstance():
2438         """getInstance()"""
2439         return _enigma.eServiceCenter_getInstance()
2440
2441     getInstance = staticmethod(getInstance)
2442 eServiceCenter_swigregister = _enigma.eServiceCenter_swigregister
2443 eServiceCenter_swigregister(eServiceCenter)
2444
2445 def eServiceCenter_getInstance():
2446     """eServiceCenter_getInstance()"""
2447     return _enigma.eServiceCenter_getInstance()
2448
2449 HTTP_TIMEOUT = _enigma.HTTP_TIMEOUT
2450 class eGstMsgContainer(object):
2451     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2452     __repr__ = _swig_repr
2453     eMsgtNone = _enigma.eGstMsgContainer_eMsgtNone
2454     eMsgtBusMessage = _enigma.eGstMsgContainer_eMsgtBusMessage
2455     eMsgtGstStateChange = _enigma.eGstMsgContainer_eMsgtGstStateChange
2456     eMsgtSubtitleAvailable = _enigma.eGstMsgContainer_eMsgtSubtitleAvailable
2457     eMsgtSubtitleCaps = _enigma.eGstMsgContainer_eMsgtSubtitleCaps
2458
2459     def __init__(self, *args):
2460         _enigma.eGstMsgContainer_swiginit(self, _enigma.new_eGstMsgContainer(*args))
2461     __swig_destroy__ = _enigma.delete_eGstMsgContainer
2462 eGstMsgContainer.getType = new_instancemethod(_enigma.eGstMsgContainer_getType, None, eGstMsgContainer)
2463 eGstMsgContainer.getTransition = new_instancemethod(_enigma.eGstMsgContainer_getTransition, None, eGstMsgContainer)
2464 eGstMsgContainer.getSource = new_instancemethod(_enigma.eGstMsgContainer_getSource, None, eGstMsgContainer)
2465 eGstMsgContainer_swigregister = _enigma.eGstMsgContainer_swigregister
2466 eGstMsgContainer_swigregister(eGstMsgContainer)
2467
2468 ctNone = _enigma.ctNone
2469 ctMPEGTS = _enigma.ctMPEGTS
2470 ctMPEGPS = _enigma.ctMPEGPS
2471 ctMKV = _enigma.ctMKV
2472 ctAVI = _enigma.ctAVI
2473 ctMP4 = _enigma.ctMP4
2474 ctVCD = _enigma.ctVCD
2475 ctCDA = _enigma.ctCDA
2476 ctFLV = _enigma.ctFLV
2477 ctWM = _enigma.ctWM
2478 class eServiceMP3_ENUMS(object):
2479     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2480
2481     def __init__(self, *args, **kwargs):
2482         raise AttributeError("No constructor defined")
2483     __repr__ = _swig_repr
2484     evAudioDecodeError = _enigma.eServiceMP3_ENUMS_evAudioDecodeError
2485     evVideoDecodeError = _enigma.eServiceMP3_ENUMS_evVideoDecodeError
2486     evPluginError = _enigma.eServiceMP3_ENUMS_evPluginError
2487     evEmbeddedCoverArt = _enigma.eServiceMP3_ENUMS_evEmbeddedCoverArt
2488     evUpdatedBitrate = _enigma.eServiceMP3_ENUMS_evUpdatedBitrate
2489     evStreamingSrcError = _enigma.eServiceMP3_ENUMS_evStreamingSrcError
2490     evFileReadError = _enigma.eServiceMP3_ENUMS_evFileReadError
2491     evTypeNotFoundError = _enigma.eServiceMP3_ENUMS_evTypeNotFoundError
2492     evGeneralGstError = _enigma.eServiceMP3_ENUMS_evGeneralGstError
2493     SUB_STREAM_FLAG_SELECT = _enigma.eServiceMP3_ENUMS_SUB_STREAM_FLAG_SELECT
2494     SUB_STREAM_FLAG_FORCED = _enigma.eServiceMP3_ENUMS_SUB_STREAM_FLAG_FORCED
2495 eServiceMP3_ENUMS_swigregister = _enigma.eServiceMP3_ENUMS_swigregister
2496 eServiceMP3_ENUMS_swigregister(eServiceMP3_ENUMS)
2497
2498 eServiceMP3 = eServiceMP3_ENUMS
2499 class eUriResolver(object):
2500     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2501     __repr__ = _swig_repr
2502
2503     def __init__(self, schemas):
2504         """__init__(eUriResolver self, StringList schemas) -> eUriResolver"""
2505         if self.__class__ == eUriResolver:
2506             _self = None
2507         else:
2508             _self = self
2509         _enigma.eUriResolver_swiginit(self, _enigma.new_eUriResolver(_self, schemas))
2510     __swig_destroy__ = _enigma.delete_eUriResolver
2511
2512     def resolve(self, service, uri):
2513         """resolve(eUriResolver self, iUriService service, std::string const & uri) -> bool"""
2514         return _enigma.eUriResolver_resolve(self, service, uri)
2515
2516
2517     def schemas(self):
2518         """schemas(eUriResolver self) -> StringList"""
2519         return _enigma.eUriResolver_schemas(self)
2520
2521
2522     def addResolver(resolver):
2523         """addResolver(eUriResolver resolver)"""
2524         return _enigma.eUriResolver_addResolver(resolver)
2525
2526     addResolver = staticmethod(addResolver)
2527
2528     def removeResolver(resolver):
2529         """removeResolver(eUriResolver resolver) -> bool"""
2530         return _enigma.eUriResolver_removeResolver(resolver)
2531
2532     removeResolver = staticmethod(removeResolver)
2533
2534     def tryResolveUri(service, uri):
2535         """tryResolveUri(iUriService service, std::string const & uri) -> bool"""
2536         return _enigma.eUriResolver_tryResolveUri(service, uri)
2537
2538     tryResolveUri = staticmethod(tryResolveUri)
2539     def __disown__(self):
2540         self.this.disown()
2541         _enigma.disown_eUriResolver(self)
2542         return weakref_proxy(self)
2543 eUriResolver.resolve = new_instancemethod(_enigma.eUriResolver_resolve, None, eUriResolver)
2544 eUriResolver.schemas = new_instancemethod(_enigma.eUriResolver_schemas, None, eUriResolver)
2545 eUriResolver_swigregister = _enigma.eUriResolver_swigregister
2546 eUriResolver_swigregister(eUriResolver)
2547
2548 def eUriResolver_addResolver(resolver):
2549     """eUriResolver_addResolver(eUriResolver resolver)"""
2550     return _enigma.eUriResolver_addResolver(resolver)
2551
2552 def eUriResolver_removeResolver(resolver):
2553     """eUriResolver_removeResolver(eUriResolver resolver) -> bool"""
2554     return _enigma.eUriResolver_removeResolver(resolver)
2555
2556 def eUriResolver_tryResolveUri(service, uri):
2557     """eUriResolver_tryResolveUri(iUriService service, std::string const & uri) -> bool"""
2558     return _enigma.eUriResolver_tryResolveUri(service, uri)
2559
2560 class eStreamProcessor(object):
2561     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2562     __repr__ = _swig_repr
2563
2564     def __init__(self, name):
2565         """__init__(eStreamProcessor self, std::string const & name) -> eStreamProcessor"""
2566         if self.__class__ == eStreamProcessor:
2567             _self = None
2568         else:
2569             _self = self
2570         _enigma.eStreamProcessor_swiginit(self, _enigma.new_eStreamProcessor(_self, name))
2571     __swig_destroy__ = _enigma.delete_eStreamProcessor
2572
2573     def getName(self):
2574         """getName(eStreamProcessor self) -> std::string const &"""
2575         return _enigma.eStreamProcessor_getName(self)
2576
2577
2578     def start(self):
2579         """start(eStreamProcessor self)"""
2580         return _enigma.eStreamProcessor_start(self)
2581
2582
2583     def stop(self):
2584         """stop(eStreamProcessor self)"""
2585         return _enigma.eStreamProcessor_stop(self)
2586
2587
2588     def pause(self):
2589         """pause(eStreamProcessor self) -> bool"""
2590         return _enigma.eStreamProcessor_pause(self)
2591
2592
2593     def resume(self):
2594         """resume(eStreamProcessor self) -> bool"""
2595         return _enigma.eStreamProcessor_resume(self)
2596
2597
2598     def seekDone(self, status):
2599         """seekDone(eStreamProcessor self, int status)"""
2600         return _enigma.eStreamProcessor_seekDone(self, status)
2601
2602
2603     def canProcess(self, streamInfos):
2604         """canProcess(eStreamProcessor self, std::vector< StreamInfo,std::allocator< StreamInfo > > & streamInfos) -> bool"""
2605         return _enigma.eStreamProcessor_canProcess(self, streamInfos)
2606
2607
2608     def parsed(self):
2609         """parsed(eStreamProcessor self)"""
2610         return _enigma.eStreamProcessor_parsed(self)
2611
2612
2613     def ready(self):
2614         """ready(eStreamProcessor self)"""
2615         return _enigma.eStreamProcessor_ready(self)
2616
2617
2618     def getStreams(self):
2619         """getStreams(eStreamProcessor self) -> std::vector< StreamInfo,std::allocator< StreamInfo > > &"""
2620         return _enigma.eStreamProcessor_getStreams(self)
2621
2622
2623     def selectVideoStream(self, *args):
2624         """
2625         selectVideoStream(eStreamProcessor self, int index, StreamRestrictions const & restrictions) -> bool
2626         selectVideoStream(eStreamProcessor self, int index) -> bool
2627         """
2628         return _enigma.eStreamProcessor_selectVideoStream(self, *args)
2629
2630
2631     def selectAudioStream(self, *args):
2632         """
2633         selectAudioStream(eStreamProcessor self, int index, StreamRestrictions const & restrictions) -> bool
2634         selectAudioStream(eStreamProcessor self, int index) -> bool
2635         """
2636         return _enigma.eStreamProcessor_selectAudioStream(self, *args)
2637
2638
2639     def deleteStream(self, index):
2640         """deleteStream(eStreamProcessor self, int index)"""
2641         return _enigma.eStreamProcessor_deleteStream(self, index)
2642
2643
2644     def getActiveVideoIndex(self):
2645         """getActiveVideoIndex(eStreamProcessor self) -> int"""
2646         return _enigma.eStreamProcessor_getActiveVideoIndex(self)
2647
2648
2649     def getActiveAudioIndex(self):
2650         """getActiveAudioIndex(eStreamProcessor self) -> int"""
2651         return _enigma.eStreamProcessor_getActiveAudioIndex(self)
2652
2653
2654     def getVideoFrames(self, frames):
2655         """getVideoFrames(eStreamProcessor self, std::vector< RawData,std::allocator< RawData > > & frames) -> bool"""
2656         return _enigma.eStreamProcessor_getVideoFrames(self, frames)
2657
2658
2659     def getAudioPackets(self, packets):
2660         """getAudioPackets(eStreamProcessor self, std::vector< RawData,std::allocator< RawData > > & packets) -> bool"""
2661         return _enigma.eStreamProcessor_getAudioPackets(self, packets)
2662
2663
2664     def getProcessors():
2665         """getProcessors() -> std::vector< eStreamProcessor *,std::allocator< eStreamProcessor * > > const &"""
2666         return _enigma.eStreamProcessor_getProcessors()
2667
2668     getProcessors = staticmethod(getProcessors)
2669
2670     def addProcessor(processor):
2671         """addProcessor(eStreamProcessor processor)"""
2672         return _enigma.eStreamProcessor_addProcessor(processor)
2673
2674     addProcessor = staticmethod(addProcessor)
2675     formatChanged = _swig_property(_enigma.eStreamProcessor_formatChanged_get, _enigma.eStreamProcessor_formatChanged_set)
2676     framerateChanged = _swig_property(_enigma.eStreamProcessor_framerateChanged_get, _enigma.eStreamProcessor_framerateChanged_set)
2677     progressiveChanged = _swig_property(_enigma.eStreamProcessor_progressiveChanged_get, _enigma.eStreamProcessor_progressiveChanged_set)
2678     def __disown__(self):
2679         self.this.disown()
2680         _enigma.disown_eStreamProcessor(self)
2681         return weakref_proxy(self)
2682 eStreamProcessor.getName = new_instancemethod(_enigma.eStreamProcessor_getName, None, eStreamProcessor)
2683 eStreamProcessor.start = new_instancemethod(_enigma.eStreamProcessor_start, None, eStreamProcessor)
2684 eStreamProcessor.stop = new_instancemethod(_enigma.eStreamProcessor_stop, None, eStreamProcessor)
2685 eStreamProcessor.pause = new_instancemethod(_enigma.eStreamProcessor_pause, None, eStreamProcessor)
2686 eStreamProcessor.resume = new_instancemethod(_enigma.eStreamProcessor_resume, None, eStreamProcessor)
2687 eStreamProcessor.seekDone = new_instancemethod(_enigma.eStreamProcessor_seekDone, None, eStreamProcessor)
2688 eStreamProcessor.canProcess = new_instancemethod(_enigma.eStreamProcessor_canProcess, None, eStreamProcessor)
2689 eStreamProcessor.parsed = new_instancemethod(_enigma.eStreamProcessor_parsed, None, eStreamProcessor)
2690 eStreamProcessor.ready = new_instancemethod(_enigma.eStreamProcessor_ready, None, eStreamProcessor)
2691 eStreamProcessor.getStreams = new_instancemethod(_enigma.eStreamProcessor_getStreams, None, eStreamProcessor)
2692 eStreamProcessor.selectVideoStream = new_instancemethod(_enigma.eStreamProcessor_selectVideoStream, None, eStreamProcessor)
2693 eStreamProcessor.selectAudioStream = new_instancemethod(_enigma.eStreamProcessor_selectAudioStream, None, eStreamProcessor)
2694 eStreamProcessor.deleteStream = new_instancemethod(_enigma.eStreamProcessor_deleteStream, None, eStreamProcessor)
2695 eStreamProcessor.getActiveVideoIndex = new_instancemethod(_enigma.eStreamProcessor_getActiveVideoIndex, None, eStreamProcessor)
2696 eStreamProcessor.getActiveAudioIndex = new_instancemethod(_enigma.eStreamProcessor_getActiveAudioIndex, None, eStreamProcessor)
2697 eStreamProcessor.getVideoFrames = new_instancemethod(_enigma.eStreamProcessor_getVideoFrames, None, eStreamProcessor)
2698 eStreamProcessor.getAudioPackets = new_instancemethod(_enigma.eStreamProcessor_getAudioPackets, None, eStreamProcessor)
2699 eStreamProcessor_swigregister = _enigma.eStreamProcessor_swigregister
2700 eStreamProcessor_swigregister(eStreamProcessor)
2701
2702 def eStreamProcessor_getProcessors():
2703     """eStreamProcessor_getProcessors() -> std::vector< eStreamProcessor *,std::allocator< eStreamProcessor * > > const &"""
2704     return _enigma.eStreamProcessor_getProcessors()
2705
2706 def eStreamProcessor_addProcessor(processor):
2707     """eStreamProcessor_addProcessor(eStreamProcessor processor)"""
2708     return _enigma.eStreamProcessor_addProcessor(processor)
2709
2710 class ePythonMessagePump(object):
2711     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2712     __repr__ = _swig_repr
2713     recv_msg = _swig_property(_enigma.ePythonMessagePump_recv_msg_get, _enigma.ePythonMessagePump_recv_msg_set)
2714
2715     def __init__(self):
2716         _enigma.ePythonMessagePump_swiginit(self, _enigma.new_ePythonMessagePump())
2717     __swig_destroy__ = _enigma.delete_ePythonMessagePump
2718 ePythonMessagePump.send = new_instancemethod(_enigma.ePythonMessagePump_send, None, ePythonMessagePump)
2719 ePythonMessagePump.start = new_instancemethod(_enigma.ePythonMessagePump_start, None, ePythonMessagePump)
2720 ePythonMessagePump.stop = new_instancemethod(_enigma.ePythonMessagePump_stop, None, ePythonMessagePump)
2721 ePythonMessagePump_swigregister = _enigma.ePythonMessagePump_swigregister
2722 ePythonMessagePump_swigregister(ePythonMessagePump)
2723
2724 class eTPM(object):
2725     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2726     __repr__ = _swig_repr
2727     DT_PROTOCOL_VERSION = _enigma.eTPM_DT_PROTOCOL_VERSION
2728     DT_TPM_VERSION = _enigma.eTPM_DT_TPM_VERSION
2729     DT_SERIAL = _enigma.eTPM_DT_SERIAL
2730     DT_LEVEL2_CERT = _enigma.eTPM_DT_LEVEL2_CERT
2731     DT_LEVEL3_CERT = _enigma.eTPM_DT_LEVEL3_CERT
2732     DT_FAB_CA_CERT = _enigma.eTPM_DT_FAB_CA_CERT
2733     DT_DATABLOCK_SIGNED = _enigma.eTPM_DT_DATABLOCK_SIGNED
2734     APDU_READ = _enigma.eTPM_APDU_READ
2735     APDU_WRITE = _enigma.eTPM_APDU_WRITE
2736
2737     def __init__(self):
2738         _enigma.eTPM_swiginit(self, _enigma.new_eTPM())
2739     __swig_destroy__ = _enigma.delete_eTPM
2740     TPMD_DT_LEVEL2_CERT = _enigma.eTPM_TPMD_DT_LEVEL2_CERT
2741     TPMD_DT_LEVEL3_CERT = _enigma.eTPM_TPMD_DT_LEVEL3_CERT
2742 eTPM.getCert = new_instancemethod(_enigma.eTPM_getCert, None, eTPM)
2743 eTPM.challenge = new_instancemethod(_enigma.eTPM_challenge, None, eTPM)
2744 eTPM.getData = new_instancemethod(_enigma.eTPM_getData, None, eTPM)
2745 eTPM.apdu = new_instancemethod(_enigma.eTPM_apdu, None, eTPM)
2746 eTPM.computeSignature = new_instancemethod(_enigma.eTPM_computeSignature, None, eTPM)
2747 eTPM.appCert = new_instancemethod(_enigma.eTPM_appCert, None, eTPM)
2748 eTPM_swigregister = _enigma.eTPM_swigregister
2749 eTPM_swigregister(eTPM)
2750
2751 class ePythonConfigQuery(object):
2752     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2753
2754     def __init__(self, *args, **kwargs):
2755         raise AttributeError("No constructor defined")
2756     __repr__ = _swig_repr
2757     getQueryFuncSignal = staticmethod(_enigma.ePythonConfigQuery_getQueryFuncSignal)
2758 ePythonConfigQuery_swigregister = _enigma.ePythonConfigQuery_swigregister
2759 ePythonConfigQuery_swigregister(ePythonConfigQuery)
2760
2761 def ePythonConfigQuery_getQueryFuncSignal():
2762     return _enigma.ePythonConfigQuery_getQueryFuncSignal()
2763 ePythonConfigQuery_getQueryFuncSignal = _enigma.ePythonConfigQuery_getQueryFuncSignal
2764
2765 class eAlsaOutput(object):
2766     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2767
2768     def __init__(self, *args, **kwargs):
2769         raise AttributeError("No constructor defined")
2770     __repr__ = _swig_repr
2771     HDMI = _enigma.eAlsaOutput_HDMI
2772     SPDIF = _enigma.eAlsaOutput_SPDIF
2773     BTPCM = _enigma.eAlsaOutput_BTPCM
2774     getInstance = staticmethod(_enigma.eAlsaOutput_getInstance)
2775 eAlsaOutput.running = new_instancemethod(_enigma.eAlsaOutput_running, None, eAlsaOutput)
2776 eAlsaOutput.close = new_instancemethod(_enigma.eAlsaOutput_close, None, eAlsaOutput)
2777 eAlsaOutput.stop = new_instancemethod(_enigma.eAlsaOutput_stop, None, eAlsaOutput)
2778 eAlsaOutput_swigregister = _enigma.eAlsaOutput_swigregister
2779 eAlsaOutput_swigregister(eAlsaOutput)
2780
2781 def eAlsaOutput_getInstance(*args):
2782     return _enigma.eAlsaOutput_getInstance(*args)
2783 eAlsaOutput_getInstance = _enigma.eAlsaOutput_getInstance
2784
2785 class eRCInput(object):
2786     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2787
2788     def __init__(self, *args, **kwargs):
2789         raise AttributeError("No constructor defined")
2790     __repr__ = _swig_repr
2791     kmNone = _enigma.eRCInput_kmNone
2792     kmAscii = _enigma.eRCInput_kmAscii
2793     kmAll = _enigma.eRCInput_kmAll
2794     getInstance = staticmethod(_enigma.eRCInput_getInstance)
2795 eRCInput.setKeyboardMode = new_instancemethod(_enigma.eRCInput_setKeyboardMode, None, eRCInput)
2796 eRCInput.getKeyboardMode = new_instancemethod(_enigma.eRCInput_getKeyboardMode, None, eRCInput)
2797 eRCInput.lock = new_instancemethod(_enigma.eRCInput_lock, None, eRCInput)
2798 eRCInput.unlock = new_instancemethod(_enigma.eRCInput_unlock, None, eRCInput)
2799 eRCInput.islocked = new_instancemethod(_enigma.eRCInput_islocked, None, eRCInput)
2800 eRCInput_swigregister = _enigma.eRCInput_swigregister
2801 eRCInput_swigregister(eRCInput)
2802
2803 def eRCInput_getInstance():
2804     return _enigma.eRCInput_getInstance()
2805 eRCInput_getInstance = _enigma.eRCInput_getInstance
2806
2807 class fbClass(object):
2808     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2809
2810     def __init__(self, *args, **kwargs):
2811         raise AttributeError("No constructor defined")
2812     __repr__ = _swig_repr
2813     getInstance = staticmethod(_enigma.fbClass_getInstance)
2814 fbClass.lock = new_instancemethod(_enigma.fbClass_lock, None, fbClass)
2815 fbClass.unlock = new_instancemethod(_enigma.fbClass_unlock, None, fbClass)
2816 fbClass.islocked = new_instancemethod(_enigma.fbClass_islocked, None, fbClass)
2817 fbClass_swigregister = _enigma.fbClass_swigregister
2818 fbClass_swigregister(fbClass)
2819
2820 def fbClass_getInstance():
2821     return _enigma.fbClass_getInstance()
2822 fbClass_getInstance = _enigma.fbClass_getInstance
2823
2824 class fontRenderClass(object):
2825     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2826
2827     def __init__(self, *args, **kwargs):
2828         raise AttributeError("No constructor defined")
2829     __repr__ = _swig_repr
2830     getInstance = staticmethod(_enigma.fontRenderClass_getInstance)
2831 fontRenderClass.getLineHeight = new_instancemethod(_enigma.fontRenderClass_getLineHeight, None, fontRenderClass)
2832 fontRenderClass_swigregister = _enigma.fontRenderClass_swigregister
2833 fontRenderClass_swigregister(fontRenderClass)
2834
2835 def fontRenderClass_getInstance():
2836     return _enigma.fontRenderClass_getInstance()
2837 fontRenderClass_getInstance = _enigma.fontRenderClass_getInstance
2838
2839 __GPIXMAP_H_INSIDE__ = _enigma.__GPIXMAP_H_INSIDE__
2840 class gPixmapPtr(object):
2841     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2842     __repr__ = _swig_repr
2843
2844     def __init__(self, *args):
2845         _enigma.gPixmapPtr_swiginit(self, _enigma.new_gPixmapPtr(*args))
2846     __swig_destroy__ = _enigma.delete_gPixmapPtr
2847 gPixmapPtr.__ref__ = new_instancemethod(_enigma.gPixmapPtr___ref__, None, gPixmapPtr)
2848 gPixmapPtr.getPtrString = new_instancemethod(_enigma.gPixmapPtr_getPtrString, None, gPixmapPtr)
2849 gPixmapPtr.__deref__ = new_instancemethod(_enigma.gPixmapPtr___deref__, None, gPixmapPtr)
2850 gPixmapPtr.size = new_instancemethod(_enigma.gPixmapPtr_size, None, gPixmapPtr)
2851 gPixmapPtr.color = new_instancemethod(_enigma.gPixmapPtr_color, None, gPixmapPtr)
2852 gPixmapPtr.colorCount = new_instancemethod(_enigma.gPixmapPtr_colorCount, None, gPixmapPtr)
2853 gPixmapPtr.colorTable = new_instancemethod(_enigma.gPixmapPtr_colorTable, None, gPixmapPtr)
2854 gPixmapPtr.setColor = new_instancemethod(_enigma.gPixmapPtr_setColor, None, gPixmapPtr)
2855 gPixmapPtr.setColorCount = new_instancemethod(_enigma.gPixmapPtr_setColorCount, None, gPixmapPtr)
2856 gPixmapPtr.setColorTable = new_instancemethod(_enigma.gPixmapPtr_setColorTable, None, gPixmapPtr)
2857 gPixmapPtr.setScaleFilter = new_instancemethod(_enigma.gPixmapPtr_setScaleFilter, None, gPixmapPtr)
2858 gPixmapPtr.scale = new_instancemethod(_enigma.gPixmapPtr_scale, None, gPixmapPtr)
2859 gPixmapPtr.read = new_instancemethod(_enigma.gPixmapPtr_read, None, gPixmapPtr)
2860 gPixmapPtr_swigregister = _enigma.gPixmapPtr_swigregister
2861 gPixmapPtr_swigregister(gPixmapPtr)
2862
2863 class gMainDC(object):
2864     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2865     __repr__ = _swig_repr
2866
2867     def __init__(self, *args):
2868         _enigma.gMainDC_swiginit(self, _enigma.new_gMainDC(*args))
2869     __swig_destroy__ = _enigma.delete_gMainDC
2870     getInstance = staticmethod(_enigma.gMainDC_getInstance)
2871 gMainDC.__ref__ = new_instancemethod(_enigma.gMainDC___ref__, None, gMainDC)
2872 gMainDC.getPtrString = new_instancemethod(_enigma.gMainDC_getPtrString, None, gMainDC)
2873 gMainDC.__deref__ = new_instancemethod(_enigma.gMainDC___deref__, None, gMainDC)
2874 gMainDC.setResolution = new_instancemethod(_enigma.gMainDC_setResolution, None, gMainDC)
2875 gMainDC_swigregister = _enigma.gMainDC_swigregister
2876 gMainDC_swigregister(gMainDC)
2877
2878 def gMainDC_getInstance():
2879     return _enigma.gMainDC_getInstance()
2880 gMainDC_getInstance = _enigma.gMainDC_getInstance
2881
2882 class ePoint(object):
2883     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2884     __repr__ = _swig_repr
2885
2886     def __init__(self, *args):
2887         """
2888         __init__(ePoint self) -> ePoint
2889         __init__(ePoint self, int xpos, int ypos) -> ePoint
2890         """
2891         _enigma.ePoint_swiginit(self, _enigma.new_ePoint(*args))
2892
2893     def isNull(self):
2894         """isNull(ePoint self) -> bool"""
2895         return _enigma.ePoint_isNull(self)
2896
2897
2898     def x(self):
2899         """x(ePoint self) -> int"""
2900         return _enigma.ePoint_x(self)
2901
2902
2903     def y(self):
2904         """y(ePoint self) -> int"""
2905         return _enigma.ePoint_y(self)
2906
2907
2908     def setX(self, x):
2909         """setX(ePoint self, int x)"""
2910         return _enigma.ePoint_setX(self, x)
2911
2912
2913     def setY(self, y):
2914         """setY(ePoint self, int y)"""
2915         return _enigma.ePoint_setY(self, y)
2916
2917
2918     def manhattanLength(self):
2919         """manhattanLength(ePoint self) -> int"""
2920         return _enigma.ePoint_manhattanLength(self)
2921
2922
2923     def rx(self):
2924         """rx(ePoint self) -> int &"""
2925         return _enigma.ePoint_rx(self)
2926
2927
2928     def ry(self):
2929         """ry(ePoint self) -> int &"""
2930         return _enigma.ePoint_ry(self)
2931
2932
2933     def __iadd__(self, p):
2934         """__iadd__(ePoint self, ePoint p) -> ePoint"""
2935         return _enigma.ePoint___iadd__(self, p)
2936
2937
2938     def __isub__(self, p):
2939         """__isub__(ePoint self, ePoint p) -> ePoint"""
2940         return _enigma.ePoint___isub__(self, p)
2941
2942
2943     def __imul__(self, *args):
2944         """
2945         __imul__(ePoint self, int c) -> ePoint
2946         __imul__(ePoint self, double c) -> ePoint
2947         """
2948         return _enigma.ePoint___imul__(self, *args)
2949
2950
2951     def __itruediv__(self, *args):
2952         return _enigma.ePoint___itruediv__(self, *args)
2953     __idiv__ = __itruediv__
2954
2955
2956     __swig_destroy__ = _enigma.delete_ePoint
2957 ePoint.isNull = new_instancemethod(_enigma.ePoint_isNull, None, ePoint)
2958 ePoint.x = new_instancemethod(_enigma.ePoint_x, None, ePoint)
2959 ePoint.y = new_instancemethod(_enigma.ePoint_y, None, ePoint)
2960 ePoint.setX = new_instancemethod(_enigma.ePoint_setX, None, ePoint)
2961 ePoint.setY = new_instancemethod(_enigma.ePoint_setY, None, ePoint)
2962 ePoint.manhattanLength = new_instancemethod(_enigma.ePoint_manhattanLength, None, ePoint)
2963 ePoint.rx = new_instancemethod(_enigma.ePoint_rx, None, ePoint)
2964 ePoint.ry = new_instancemethod(_enigma.ePoint_ry, None, ePoint)
2965 ePoint.__iadd__ = new_instancemethod(_enigma.ePoint___iadd__, None, ePoint)
2966 ePoint.__isub__ = new_instancemethod(_enigma.ePoint___isub__, None, ePoint)
2967 ePoint.__imul__ = new_instancemethod(_enigma.ePoint___imul__, None, ePoint)
2968 ePoint_swigregister = _enigma.ePoint_swigregister
2969 ePoint_swigregister(ePoint)
2970
2971 class eRect(object):
2972     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2973     __repr__ = _swig_repr
2974
2975     def __init__(self, *args):
2976         """
2977         __init__(eRect self) -> eRect
2978         __init__(eRect self, ePoint topleft, ePoint bottomright) -> eRect
2979         __init__(eRect self, ePoint topleft, eSize size) -> eRect
2980         __init__(eRect self, eSize size) -> eRect
2981         __init__(eRect self, int width, int height) -> eRect
2982         __init__(eRect self, int left, int top, int width, int height) -> eRect
2983         """
2984         _enigma.eRect_swiginit(self, _enigma.new_eRect(*args))
2985
2986     def empty(self):
2987         """empty(eRect self) -> bool"""
2988         return _enigma.eRect_empty(self)
2989
2990
2991     def valid(self):
2992         """valid(eRect self) -> bool"""
2993         return _enigma.eRect_valid(self)
2994
2995
2996     def normalize(self):
2997         """normalize(eRect self) -> eRect"""
2998         return _enigma.eRect_normalize(self)
2999
3000
3001     def left(self):
3002         """left(eRect self) -> int"""
3003         return _enigma.eRect_left(self)
3004
3005
3006     def top(self):
3007         """top(eRect self) -> int"""
3008         return _enigma.eRect_top(self)
3009
3010
3011     def right(self):
3012         """right(eRect self) -> int"""
3013         return _enigma.eRect_right(self)
3014
3015
3016     def bottom(self):
3017         """bottom(eRect self) -> int"""
3018         return _enigma.eRect_bottom(self)
3019
3020
3021     def rLeft(self):
3022         """rLeft(eRect self) -> int &"""
3023         return _enigma.eRect_rLeft(self)
3024
3025
3026     def rTop(self):
3027         """rTop(eRect self) -> int &"""
3028         return _enigma.eRect_rTop(self)
3029
3030
3031     def rRight(self):
3032         """rRight(eRect self) -> int &"""
3033         return _enigma.eRect_rRight(self)
3034
3035
3036     def rBottom(self):
3037         """rBottom(eRect self) -> int &"""
3038         return _enigma.eRect_rBottom(self)
3039
3040
3041     def x(self):
3042         """x(eRect self) -> int"""
3043         return _enigma.eRect_x(self)
3044
3045
3046     def y(self):
3047         """y(eRect self) -> int"""
3048         return _enigma.eRect_y(self)
3049
3050
3051     def setLeft(self, pos):
3052         """setLeft(eRect self, int pos)"""
3053         return _enigma.eRect_setLeft(self, pos)
3054
3055
3056     def setTop(self, pos):
3057         """setTop(eRect self, int pos)"""
3058         return _enigma.eRect_setTop(self, pos)
3059
3060
3061     def setRight(self, pos):
3062         """setRight(eRect self, int pos)"""
3063         return _enigma.eRect_setRight(self, pos)
3064
3065
3066     def setBottom(self, pos):
3067         """setBottom(eRect self, int pos)"""
3068         return _enigma.eRect_setBottom(self, pos)
3069
3070
3071     def setX(self, x):
3072         """setX(eRect self, int x)"""
3073         return _enigma.eRect_setX(self, x)
3074
3075
3076     def setY(self, y):
3077         """setY(eRect self, int y)"""
3078         return _enigma.eRect_setY(self, y)
3079
3080
3081     def topLeft(self):
3082         """topLeft(eRect self) -> ePoint"""
3083         return _enigma.eRect_topLeft(self)
3084
3085
3086     def bottomRight(self):
3087         """bottomRight(eRect self) -> ePoint"""
3088         return _enigma.eRect_bottomRight(self)
3089
3090
3091     def topRight(self):
3092         """topRight(eRect self) -> ePoint"""
3093         return _enigma.eRect_topRight(self)
3094
3095
3096     def bottomLeft(self):
3097         """bottomLeft(eRect self) -> ePoint"""
3098         return _enigma.eRect_bottomLeft(self)
3099
3100
3101     def topLeft1(self):
3102         """topLeft1(eRect self) -> ePoint"""
3103         return _enigma.eRect_topLeft1(self)
3104
3105
3106     def bottomRight1(self):
3107         """bottomRight1(eRect self) -> ePoint"""
3108         return _enigma.eRect_bottomRight1(self)
3109
3110
3111     def topRight1(self):
3112         """topRight1(eRect self) -> ePoint"""
3113         return _enigma.eRect_topRight1(self)
3114
3115
3116     def bottomLeft1(self):
3117         """bottomLeft1(eRect self) -> ePoint"""
3118         return _enigma.eRect_bottomLeft1(self)
3119
3120
3121     def center(self):
3122         """center(eRect self) -> ePoint"""
3123         return _enigma.eRect_center(self)
3124
3125
3126     def rect(self, x, y, w, h):
3127         """rect(eRect self, int * x, int * y, int * w, int * h)"""
3128         return _enigma.eRect_rect(self, x, y, w, h)
3129
3130
3131     def coords(self, x1, y1, x2, y2):
3132         """coords(eRect self, int * x1, int * y1, int * x2, int * y2)"""
3133         return _enigma.eRect_coords(self, x1, y1, x2, y2)
3134
3135
3136     def moveTopLeft(self, p):
3137         """moveTopLeft(eRect self, ePoint p)"""
3138         return _enigma.eRect_moveTopLeft(self, p)
3139
3140
3141     def moveBottomRight(self, p):
3142         """moveBottomRight(eRect self, ePoint p)"""
3143         return _enigma.eRect_moveBottomRight(self, p)
3144
3145
3146     def moveTopRight(self, p):
3147         """moveTopRight(eRect self, ePoint p)"""
3148         return _enigma.eRect_moveTopRight(self, p)
3149
3150
3151     def moveBottomLeft(self, p):
3152         """moveBottomLeft(eRect self, ePoint p)"""
3153         return _enigma.eRect_moveBottomLeft(self, p)
3154
3155
3156     def moveCenter(self, p):
3157         """moveCenter(eRect self, ePoint p)"""
3158         return _enigma.eRect_moveCenter(self, p)
3159
3160
3161     def moveBy(self, *args):
3162         """
3163         moveBy(eRect self, int dx, int dy)
3164         moveBy(eRect self, ePoint r)
3165         """
3166         return _enigma.eRect_moveBy(self, *args)
3167
3168
3169     def setRect(self, x, y, w, h):
3170         """setRect(eRect self, int x, int y, int w, int h)"""
3171         return _enigma.eRect_setRect(self, x, y, w, h)
3172
3173
3174     def setCoords(self, x1, y1, x2, y2):
3175         """setCoords(eRect self, int x1, int y1, int x2, int y2)"""
3176         return _enigma.eRect_setCoords(self, x1, y1, x2, y2)
3177
3178
3179     def size(self):
3180         """size(eRect self) -> eSize"""
3181         return _enigma.eRect_size(self)
3182
3183
3184     def width(self):
3185         """width(eRect self) -> int"""
3186         return _enigma.eRect_width(self)
3187
3188
3189     def height(self):
3190         """height(eRect self) -> int"""
3191         return _enigma.eRect_height(self)
3192
3193
3194     def setWidth(self, w):
3195         """setWidth(eRect self, int w)"""
3196         return _enigma.eRect_setWidth(self, w)
3197
3198
3199     def setHeight(self, h):
3200         """setHeight(eRect self, int h)"""
3201         return _enigma.eRect_setHeight(self, h)
3202
3203
3204     def setSize(self, s):
3205         """setSize(eRect self, eSize s)"""
3206         return _enigma.eRect_setSize(self, s)
3207
3208
3209     def setEmpty(self):
3210         """setEmpty(eRect self)"""
3211         return _enigma.eRect_setEmpty(self)
3212
3213
3214     def __or__(self, r):
3215         """__or__(eRect self, eRect r) -> eRect"""
3216         return _enigma.eRect___or__(self, r)
3217
3218
3219     def __and__(self, r):
3220         """__and__(eRect self, eRect r) -> eRect"""
3221         return _enigma.eRect___and__(self, r)
3222
3223
3224     def __ior__(self, r):
3225         """__ior__(eRect self, eRect r) -> eRect"""
3226         return _enigma.eRect___ior__(self, r)
3227
3228
3229     def __iand__(self, r):
3230         """__iand__(eRect self, eRect r) -> eRect"""
3231         return _enigma.eRect___iand__(self, r)
3232
3233
3234     def contains(self, *args):
3235         """
3236         contains(eRect self, ePoint p) -> bool
3237         contains(eRect self, int x, int y) -> bool
3238         contains(eRect self, eRect r) -> bool
3239         """
3240         return _enigma.eRect_contains(self, *args)
3241
3242
3243     def unite(self, r):
3244         """unite(eRect self, eRect r) -> eRect"""
3245         return _enigma.eRect_unite(self, r)
3246
3247
3248     def intersect(self, r):
3249         """intersect(eRect self, eRect r) -> eRect"""
3250         return _enigma.eRect_intersect(self, r)
3251
3252
3253     def intersects(self, r):
3254         """intersects(eRect self, eRect r) -> bool"""
3255         return _enigma.eRect_intersects(self, r)
3256
3257
3258     def scaleToCenterOf(self, other):
3259         """scaleToCenterOf(eRect self, eRect other)"""
3260         return _enigma.eRect_scaleToCenterOf(self, other)
3261
3262
3263     def scaleToWidthOf(self, other):
3264         """scaleToWidthOf(eRect self, eRect other)"""
3265         return _enigma.eRect_scaleToWidthOf(self, other)
3266
3267
3268     def scaleToHeightOf(self, other):
3269         """scaleToHeightOf(eRect self, eRect other)"""
3270         return _enigma.eRect_scaleToHeightOf(self, other)
3271
3272
3273     def scaleToFill(self, other):
3274         """scaleToFill(eRect self, eRect other)"""
3275         return _enigma.eRect_scaleToFill(self, other)
3276
3277
3278     def centerIn(self, other):
3279         """centerIn(eRect self, eRect other)"""
3280         return _enigma.eRect_centerIn(self, other)
3281
3282
3283     def emptyRect():
3284         """emptyRect() -> eRect"""
3285         return _enigma.eRect_emptyRect()
3286
3287     emptyRect = staticmethod(emptyRect)
3288
3289     def invalidRect():
3290         """invalidRect() -> eRect"""
3291         return _enigma.eRect_invalidRect()
3292
3293     invalidRect = staticmethod(invalidRect)
3294
3295     def scale(self, x_n, x_d, y_n, y_d):
3296         """scale(eRect self, int x_n, int x_d, int y_n, int y_d)"""
3297         return _enigma.eRect_scale(self, x_n, x_d, y_n, y_d)
3298
3299     __swig_destroy__ = _enigma.delete_eRect
3300 eRect.empty = new_instancemethod(_enigma.eRect_empty, None, eRect)
3301 eRect.valid = new_instancemethod(_enigma.eRect_valid, None, eRect)
3302 eRect.normalize = new_instancemethod(_enigma.eRect_normalize, None, eRect)
3303 eRect.left = new_instancemethod(_enigma.eRect_left, None, eRect)
3304 eRect.top = new_instancemethod(_enigma.eRect_top, None, eRect)
3305 eRect.right = new_instancemethod(_enigma.eRect_right, None, eRect)
3306 eRect.bottom = new_instancemethod(_enigma.eRect_bottom, None, eRect)
3307 eRect.rLeft = new_instancemethod(_enigma.eRect_rLeft, None, eRect)
3308 eRect.rTop = new_instancemethod(_enigma.eRect_rTop, None, eRect)
3309 eRect.rRight = new_instancemethod(_enigma.eRect_rRight, None, eRect)
3310 eRect.rBottom = new_instancemethod(_enigma.eRect_rBottom, None, eRect)
3311 eRect.x = new_instancemethod(_enigma.eRect_x, None, eRect)
3312 eRect.y = new_instancemethod(_enigma.eRect_y, None, eRect)
3313 eRect.setLeft = new_instancemethod(_enigma.eRect_setLeft, None, eRect)
3314 eRect.setTop = new_instancemethod(_enigma.eRect_setTop, None, eRect)
3315 eRect.setRight = new_instancemethod(_enigma.eRect_setRight, None, eRect)
3316 eRect.setBottom = new_instancemethod(_enigma.eRect_setBottom, None, eRect)
3317 eRect.setX = new_instancemethod(_enigma.eRect_setX, None, eRect)
3318 eRect.setY = new_instancemethod(_enigma.eRect_setY, None, eRect)
3319 eRect.topLeft = new_instancemethod(_enigma.eRect_topLeft, None, eRect)
3320 eRect.bottomRight = new_instancemethod(_enigma.eRect_bottomRight, None, eRect)
3321 eRect.topRight = new_instancemethod(_enigma.eRect_topRight, None, eRect)
3322 eRect.bottomLeft = new_instancemethod(_enigma.eRect_bottomLeft, None, eRect)
3323 eRect.topLeft1 = new_instancemethod(_enigma.eRect_topLeft1, None, eRect)
3324 eRect.bottomRight1 = new_instancemethod(_enigma.eRect_bottomRight1, None, eRect)
3325 eRect.topRight1 = new_instancemethod(_enigma.eRect_topRight1, None, eRect)
3326 eRect.bottomLeft1 = new_instancemethod(_enigma.eRect_bottomLeft1, None, eRect)
3327 eRect.center = new_instancemethod(_enigma.eRect_center, None, eRect)
3328 eRect.rect = new_instancemethod(_enigma.eRect_rect, None, eRect)
3329 eRect.coords = new_instancemethod(_enigma.eRect_coords, None, eRect)
3330 eRect.moveTopLeft = new_instancemethod(_enigma.eRect_moveTopLeft, None, eRect)
3331 eRect.moveBottomRight = new_instancemethod(_enigma.eRect_moveBottomRight, None, eRect)
3332 eRect.moveTopRight = new_instancemethod(_enigma.eRect_moveTopRight, None, eRect)
3333 eRect.moveBottomLeft = new_instancemethod(_enigma.eRect_moveBottomLeft, None, eRect)
3334 eRect.moveCenter = new_instancemethod(_enigma.eRect_moveCenter, None, eRect)
3335 eRect.moveBy = new_instancemethod(_enigma.eRect_moveBy, None, eRect)
3336 eRect.setRect = new_instancemethod(_enigma.eRect_setRect, None, eRect)
3337 eRect.setCoords = new_instancemethod(_enigma.eRect_setCoords, None, eRect)
3338 eRect.size = new_instancemethod(_enigma.eRect_size, None, eRect)
3339 eRect.width = new_instancemethod(_enigma.eRect_width, None, eRect)
3340 eRect.height = new_instancemethod(_enigma.eRect_height, None, eRect)
3341 eRect.setWidth = new_instancemethod(_enigma.eRect_setWidth, None, eRect)
3342 eRect.setHeight = new_instancemethod(_enigma.eRect_setHeight, None, eRect)
3343 eRect.setSize = new_instancemethod(_enigma.eRect_setSize, None, eRect)
3344 eRect.setEmpty = new_instancemethod(_enigma.eRect_setEmpty, None, eRect)
3345 eRect.__or__ = new_instancemethod(_enigma.eRect___or__, None, eRect)
3346 eRect.__and__ = new_instancemethod(_enigma.eRect___and__, None, eRect)
3347 eRect.__ior__ = new_instancemethod(_enigma.eRect___ior__, None, eRect)
3348 eRect.__iand__ = new_instancemethod(_enigma.eRect___iand__, None, eRect)
3349 eRect.contains = new_instancemethod(_enigma.eRect_contains, None, eRect)
3350 eRect.unite = new_instancemethod(_enigma.eRect_unite, None, eRect)
3351 eRect.intersect = new_instancemethod(_enigma.eRect_intersect, None, eRect)
3352 eRect.intersects = new_instancemethod(_enigma.eRect_intersects, None, eRect)
3353 eRect.scaleToCenterOf = new_instancemethod(_enigma.eRect_scaleToCenterOf, None, eRect)
3354 eRect.scaleToWidthOf = new_instancemethod(_enigma.eRect_scaleToWidthOf, None, eRect)
3355 eRect.scaleToHeightOf = new_instancemethod(_enigma.eRect_scaleToHeightOf, None, eRect)
3356 eRect.scaleToFill = new_instancemethod(_enigma.eRect_scaleToFill, None, eRect)
3357 eRect.centerIn = new_instancemethod(_enigma.eRect_centerIn, None, eRect)
3358 eRect.scale = new_instancemethod(_enigma.eRect_scale, None, eRect)
3359 eRect_swigregister = _enigma.eRect_swigregister
3360 eRect_swigregister(eRect)
3361
3362 def eRect_emptyRect():
3363     """eRect_emptyRect() -> eRect"""
3364     return _enigma.eRect_emptyRect()
3365
3366 def eRect_invalidRect():
3367     """eRect_invalidRect() -> eRect"""
3368     return _enigma.eRect_invalidRect()
3369
3370 class eSize(object):
3371     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3372     __repr__ = _swig_repr
3373
3374     def __init__(self, *args):
3375         """
3376         __init__(eSize self) -> eSize
3377         __init__(eSize self, int w, int h) -> eSize
3378         """
3379         _enigma.eSize_swiginit(self, _enigma.new_eSize(*args))
3380
3381     def isNull(self):
3382         """isNull(eSize self) -> bool"""
3383         return _enigma.eSize_isNull(self)
3384
3385
3386     def isEmpty(self):
3387         """isEmpty(eSize self) -> bool"""
3388         return _enigma.eSize_isEmpty(self)
3389
3390
3391     def isValid(self):
3392         """isValid(eSize self) -> bool"""
3393         return _enigma.eSize_isValid(self)
3394
3395
3396     def width(self):
3397         """width(eSize self) -> int"""
3398         return _enigma.eSize_width(self)
3399
3400
3401     def height(self):
3402         """height(eSize self) -> int"""
3403         return _enigma.eSize_height(self)
3404
3405
3406     def setWidth(self, w):
3407         """setWidth(eSize self, int w)"""
3408         return _enigma.eSize_setWidth(self, w)
3409
3410
3411     def setHeight(self, h):
3412         """setHeight(eSize self, int h)"""
3413         return _enigma.eSize_setHeight(self, h)
3414
3415
3416     def transpose(self):
3417         """transpose(eSize self)"""
3418         return _enigma.eSize_transpose(self)
3419
3420
3421     def scale(self, *args):
3422         """
3423         scale(eSize self, eSize dst, eSize aspect) -> eSize
3424         scale(eSize self, eSize dst) -> eSize
3425         """
3426         return _enigma.eSize_scale(self, *args)
3427
3428
3429     def expandedTo(self, arg2):
3430         """expandedTo(eSize self, eSize arg2) -> eSize"""
3431         return _enigma.eSize_expandedTo(self, arg2)
3432
3433
3434     def boundedTo(self, arg2):
3435         """boundedTo(eSize self, eSize arg2) -> eSize"""
3436         return _enigma.eSize_boundedTo(self, arg2)
3437
3438
3439     def rwidth(self):
3440         """rwidth(eSize self) -> int &"""
3441         return _enigma.eSize_rwidth(self)
3442
3443
3444     def rheight(self):
3445         """rheight(eSize self) -> int &"""
3446         return _enigma.eSize_rheight(self)
3447
3448
3449     def __iadd__(self, arg2):
3450         """__iadd__(eSize self, eSize arg2) -> eSize"""
3451         return _enigma.eSize___iadd__(self, arg2)
3452
3453
3454     def __isub__(self, arg2):
3455         """__isub__(eSize self, eSize arg2) -> eSize"""
3456         return _enigma.eSize___isub__(self, arg2)
3457
3458
3459     def __imul__(self, *args):
3460         """
3461         __imul__(eSize self, int c) -> eSize
3462         __imul__(eSize self, double c) -> eSize
3463         """
3464         return _enigma.eSize___imul__(self, *args)
3465
3466
3467     def __itruediv__(self, *args):
3468         return _enigma.eSize___itruediv__(self, *args)
3469     __idiv__ = __itruediv__
3470
3471
3472     __swig_destroy__ = _enigma.delete_eSize
3473 eSize.isNull = new_instancemethod(_enigma.eSize_isNull, None, eSize)
3474 eSize.isEmpty = new_instancemethod(_enigma.eSize_isEmpty, None, eSize)
3475 eSize.isValid = new_instancemethod(_enigma.eSize_isValid, None, eSize)
3476 eSize.width = new_instancemethod(_enigma.eSize_width, None, eSize)
3477 eSize.height = new_instancemethod(_enigma.eSize_height, None, eSize)
3478 eSize.setWidth = new_instancemethod(_enigma.eSize_setWidth, None, eSize)
3479 eSize.setHeight = new_instancemethod(_enigma.eSize_setHeight, None, eSize)
3480 eSize.transpose = new_instancemethod(_enigma.eSize_transpose, None, eSize)
3481 eSize.scale = new_instancemethod(_enigma.eSize_scale, None, eSize)
3482 eSize.expandedTo = new_instancemethod(_enigma.eSize_expandedTo, None, eSize)
3483 eSize.boundedTo = new_instancemethod(_enigma.eSize_boundedTo, None, eSize)
3484 eSize.rwidth = new_instancemethod(_enigma.eSize_rwidth, None, eSize)
3485 eSize.rheight = new_instancemethod(_enigma.eSize_rheight, None, eSize)
3486 eSize.__iadd__ = new_instancemethod(_enigma.eSize___iadd__, None, eSize)
3487 eSize.__isub__ = new_instancemethod(_enigma.eSize___isub__, None, eSize)
3488 eSize.__imul__ = new_instancemethod(_enigma.eSize___imul__, None, eSize)
3489 eSize_swigregister = _enigma.eSize_swigregister
3490 eSize_swigregister(eSize)
3491
3492 class eMatrix(object):
3493     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3494     __repr__ = _swig_repr
3495
3496     def __init__(self, *args):
3497         """
3498         __init__(eMatrix self) -> eMatrix
3499         __init__(eMatrix self, unsigned int rows, unsigned int columns) -> eMatrix
3500         __init__(eMatrix self, eMatrix B) -> eMatrix
3501         """
3502         _enigma.eMatrix_swiginit(self, _enigma.new_eMatrix(*args))
3503     __swig_destroy__ = _enigma.delete_eMatrix
3504
3505     def __call__(self, *args):
3506         """
3507         __call__(eMatrix self, unsigned int i, unsigned int j) -> float
3508         __call__(eMatrix self, unsigned int i, unsigned int j) -> float const &
3509         """
3510         return _enigma.eMatrix___call__(self, *args)
3511
3512
3513     def __eq__(self, B):
3514         """__eq__(eMatrix self, eMatrix B) -> bool"""
3515         return _enigma.eMatrix___eq__(self, B)
3516
3517
3518     def __ne__(self, B):
3519         """__ne__(eMatrix self, eMatrix B) -> bool"""
3520         return _enigma.eMatrix___ne__(self, B)
3521
3522
3523     def __imul__(self, *args):
3524         """
3525         __imul__(eMatrix self, eMatrix B) -> eMatrix
3526         __imul__(eMatrix self, float scalar) -> eMatrix
3527         """
3528         return _enigma.eMatrix___imul__(self, *args)
3529
3530
3531     def __mul__(self, *args):
3532         """
3533         __mul__(eMatrix self, eMatrix B) -> eMatrix
3534         __mul__(eMatrix self, float scalar) -> eMatrix
3535         """
3536         return _enigma.eMatrix___mul__(self, *args)
3537
3538
3539     def __iadd__(self, B):
3540         """__iadd__(eMatrix self, eMatrix B) -> eMatrix"""
3541         return _enigma.eMatrix___iadd__(self, B)
3542
3543
3544     def __add__(self, B):
3545         """__add__(eMatrix self, eMatrix B) -> eMatrix"""
3546         return _enigma.eMatrix___add__(self, B)
3547
3548
3549     def __isub__(self, B):
3550         """__isub__(eMatrix self, eMatrix B) -> eMatrix"""
3551         return _enigma.eMatrix___isub__(self, B)
3552
3553
3554     def __sub__(self, B):
3555         """__sub__(eMatrix self, eMatrix B) -> eMatrix"""
3556         return _enigma.eMatrix___sub__(self, B)
3557
3558
3559     def rows(self):
3560         """rows(eMatrix self) -> unsigned int"""
3561         return _enigma.eMatrix_rows(self)
3562
3563
3564     def columns(self):
3565         """columns(eMatrix self) -> unsigned int"""
3566         return _enigma.eMatrix_columns(self)
3567
3568
3569     def initialize(self, rows, columns, a=None):
3570         """
3571         initialize(eMatrix self, unsigned int rows, unsigned int columns, float * a=None)
3572         initialize(eMatrix self, unsigned int rows, unsigned int columns)
3573         """
3574         return _enigma.eMatrix_initialize(self, rows, columns, a)
3575
3576 eMatrix.__call__ = new_instancemethod(_enigma.eMatrix___call__, None, eMatrix)
3577 eMatrix.__eq__ = new_instancemethod(_enigma.eMatrix___eq__, None, eMatrix)
3578 eMatrix.__ne__ = new_instancemethod(_enigma.eMatrix___ne__, None, eMatrix)
3579 eMatrix.__imul__ = new_instancemethod(_enigma.eMatrix___imul__, None, eMatrix)
3580 eMatrix.__mul__ = new_instancemethod(_enigma.eMatrix___mul__, None, eMatrix)
3581 eMatrix.__iadd__ = new_instancemethod(_enigma.eMatrix___iadd__, None, eMatrix)
3582 eMatrix.__add__ = new_instancemethod(_enigma.eMatrix___add__, None, eMatrix)
3583 eMatrix.__isub__ = new_instancemethod(_enigma.eMatrix___isub__, None, eMatrix)
3584 eMatrix.__sub__ = new_instancemethod(_enigma.eMatrix___sub__, None, eMatrix)
3585 eMatrix.rows = new_instancemethod(_enigma.eMatrix_rows, None, eMatrix)
3586 eMatrix.columns = new_instancemethod(_enigma.eMatrix_columns, None, eMatrix)
3587 eMatrix.initialize = new_instancemethod(_enigma.eMatrix_initialize, None, eMatrix)
3588 eMatrix_swigregister = _enigma.eMatrix_swigregister
3589 eMatrix_swigregister(eMatrix)
3590
3591 class eSquareMatrix(eMatrix):
3592     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3593     __repr__ = _swig_repr
3594     NullMatrix = _enigma.eSquareMatrix_NullMatrix
3595     IdentityMatrix = _enigma.eSquareMatrix_IdentityMatrix
3596
3597     def __init__(self, *args):
3598         """
3599         __init__(eSquareMatrix self, unsigned int order, enum eSquareMatrix::MatrixType type) -> eSquareMatrix
3600         __init__(eSquareMatrix self, unsigned int order) -> eSquareMatrix
3601         """
3602         _enigma.eSquareMatrix_swiginit(self, _enigma.new_eSquareMatrix(*args))
3603     __swig_destroy__ = _enigma.delete_eSquareMatrix
3604 eSquareMatrix_swigregister = _enigma.eSquareMatrix_swigregister
3605 eSquareMatrix_swigregister(eSquareMatrix)
3606
3607 class eMatrix4x4(eSquareMatrix):
3608     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3609     __repr__ = _swig_repr
3610
3611     def __init__(self, *args):
3612         """
3613         __init__(eMatrix4x4 self, enum eSquareMatrix::MatrixType type) -> eMatrix4x4
3614         __init__(eMatrix4x4 self) -> eMatrix4x4
3615         __init__(eMatrix4x4 self, eMatrix B) -> eMatrix4x4
3616         """
3617         _enigma.eMatrix4x4_swiginit(self, _enigma.new_eMatrix4x4(*args))
3618
3619     def __call__(self, *args):
3620         """
3621         __call__(eMatrix4x4 self, unsigned int i, unsigned int j) -> float
3622         __call__(eMatrix4x4 self, unsigned int i, unsigned int j) -> float const &
3623         """
3624         return _enigma.eMatrix4x4___call__(self, *args)
3625
3626
3627     def __imul__(self, *args):
3628         """
3629         __imul__(eMatrix4x4 self, eMatrix4x4 B) -> eMatrix4x4
3630         __imul__(eMatrix4x4 self, float scalar) -> eMatrix4x4
3631         """
3632         return _enigma.eMatrix4x4___imul__(self, *args)
3633
3634
3635     def __mul__(self, *args):
3636         """
3637         __mul__(eMatrix4x4 self, eMatrix4x4 B) -> eMatrix4x4
3638         __mul__(eMatrix4x4 self, float scalar) -> eMatrix4x4
3639         """
3640         return _enigma.eMatrix4x4___mul__(self, *args)
3641
3642
3643     def identity():
3644         """identity() -> eMatrix4x4"""
3645         return _enigma.eMatrix4x4_identity()
3646
3647     identity = staticmethod(identity)
3648
3649     def orthographic(left, right, top, bottom, near, far):
3650         """orthographic(float left, float right, float top, float bottom, float near, float far) -> eMatrix4x4"""
3651         return _enigma.eMatrix4x4_orthographic(left, right, top, bottom, near, far)
3652
3653     orthographic = staticmethod(orthographic)
3654
3655     def perspective(angle, near, far, aspect):
3656         """perspective(float angle, float near, float far, float aspect) -> eMatrix4x4"""
3657         return _enigma.eMatrix4x4_perspective(angle, near, far, aspect)
3658
3659     perspective = staticmethod(perspective)
3660
3661     def rotateX(deg):
3662         """rotateX(float deg) -> eMatrix4x4"""
3663         return _enigma.eMatrix4x4_rotateX(deg)
3664
3665     rotateX = staticmethod(rotateX)
3666
3667     def rotateY(deg):
3668         """rotateY(float deg) -> eMatrix4x4"""
3669         return _enigma.eMatrix4x4_rotateY(deg)
3670
3671     rotateY = staticmethod(rotateY)
3672
3673     def rotateZ(deg):
3674         """rotateZ(float deg) -> eMatrix4x4"""
3675         return _enigma.eMatrix4x4_rotateZ(deg)
3676
3677     rotateZ = staticmethod(rotateZ)
3678
3679     def scale(x, y, z):
3680         """scale(float x, float y, float z) -> eMatrix4x4"""
3681         return _enigma.eMatrix4x4_scale(x, y, z)
3682
3683     scale = staticmethod(scale)
3684
3685     def translate(self, x, y, z):
3686         """translate(eMatrix4x4 self, float x, float y, float z) -> eMatrix4x4"""
3687         return _enigma.eMatrix4x4_translate(self, x, y, z)
3688
3689     __swig_destroy__ = _enigma.delete_eMatrix4x4
3690 eMatrix4x4.__call__ = new_instancemethod(_enigma.eMatrix4x4___call__, None, eMatrix4x4)
3691 eMatrix4x4.__imul__ = new_instancemethod(_enigma.eMatrix4x4___imul__, None, eMatrix4x4)
3692 eMatrix4x4.__mul__ = new_instancemethod(_enigma.eMatrix4x4___mul__, None, eMatrix4x4)
3693 eMatrix4x4.translate = new_instancemethod(_enigma.eMatrix4x4_translate, None, eMatrix4x4)
3694 eMatrix4x4_swigregister = _enigma.eMatrix4x4_swigregister
3695 eMatrix4x4_swigregister(eMatrix4x4)
3696
3697 def eMatrix4x4_identity():
3698     """eMatrix4x4_identity() -> eMatrix4x4"""
3699     return _enigma.eMatrix4x4_identity()
3700
3701 def eMatrix4x4_orthographic(left, right, top, bottom, near, far):
3702     """eMatrix4x4_orthographic(float left, float right, float top, float bottom, float near, float far) -> eMatrix4x4"""
3703     return _enigma.eMatrix4x4_orthographic(left, right, top, bottom, near, far)
3704
3705 def eMatrix4x4_perspective(angle, near, far, aspect):
3706     """eMatrix4x4_perspective(float angle, float near, float far, float aspect) -> eMatrix4x4"""
3707     return _enigma.eMatrix4x4_perspective(angle, near, far, aspect)
3708
3709 def eMatrix4x4_rotateX(deg):
3710     """eMatrix4x4_rotateX(float deg) -> eMatrix4x4"""
3711     return _enigma.eMatrix4x4_rotateX(deg)
3712
3713 def eMatrix4x4_rotateY(deg):
3714     """eMatrix4x4_rotateY(float deg) -> eMatrix4x4"""
3715     return _enigma.eMatrix4x4_rotateY(deg)
3716
3717 def eMatrix4x4_rotateZ(deg):
3718     """eMatrix4x4_rotateZ(float deg) -> eMatrix4x4"""
3719     return _enigma.eMatrix4x4_rotateZ(deg)
3720
3721 def eMatrix4x4_scale(x, y, z):
3722     """eMatrix4x4_scale(float x, float y, float z) -> eMatrix4x4"""
3723     return _enigma.eMatrix4x4_scale(x, y, z)
3724
3725 class eMatrix3d(object):
3726     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3727     __repr__ = _swig_repr
3728
3729     def __init__(self, rows, columns, planes):
3730         """__init__(eMatrix3d self, unsigned int rows, unsigned int columns, unsigned int planes) -> eMatrix3d"""
3731         _enigma.eMatrix3d_swiginit(self, _enigma.new_eMatrix3d(rows, columns, planes))
3732
3733     def __call__(self, *args):
3734         """
3735         __call__(eMatrix3d self, unsigned int i, unsigned int j, unsigned int k) -> float
3736         __call__(eMatrix3d self, unsigned int i, unsigned int j, unsigned int k) -> float const &
3737         """
3738         return _enigma.eMatrix3d___call__(self, *args)
3739
3740
3741     def at(self, *args):
3742         """
3743         at(eMatrix3d self, size_t n) -> eMatrix
3744         at(eMatrix3d self, size_t n) -> eMatrix
3745         """
3746         return _enigma.eMatrix3d_at(self, *args)
3747
3748     __swig_destroy__ = _enigma.delete_eMatrix3d
3749 eMatrix3d.__call__ = new_instancemethod(_enigma.eMatrix3d___call__, None, eMatrix3d)
3750 eMatrix3d.at = new_instancemethod(_enigma.eMatrix3d_at, None, eMatrix3d)
3751 eMatrix3d_swigregister = _enigma.eMatrix3d_swigregister
3752 eMatrix3d_swigregister(eMatrix3d)
3753
3754 class eMatrix3d4x4(eMatrix3d):
3755     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3756     __repr__ = _swig_repr
3757
3758     def __init__(self, planes):
3759         """__init__(eMatrix3d4x4 self, unsigned int planes) -> eMatrix3d4x4"""
3760         _enigma.eMatrix3d4x4_swiginit(self, _enigma.new_eMatrix3d4x4(planes))
3761
3762     def __call__(self, *args):
3763         """
3764         __call__(eMatrix3d4x4 self, unsigned int i, unsigned int j, unsigned int k) -> float
3765         __call__(eMatrix3d4x4 self, unsigned int i, unsigned int j, unsigned int k) -> float const &
3766         """
3767         return _enigma.eMatrix3d4x4___call__(self, *args)
3768
3769
3770     def at(self, *args):
3771         """
3772         at(eMatrix3d4x4 self, size_t n) -> eMatrix4x4
3773         at(eMatrix3d4x4 self, size_t n) -> eMatrix4x4
3774         """
3775         return _enigma.eMatrix3d4x4_at(self, *args)
3776
3777     __swig_destroy__ = _enigma.delete_eMatrix3d4x4
3778 eMatrix3d4x4.__call__ = new_instancemethod(_enigma.eMatrix3d4x4___call__, None, eMatrix3d4x4)
3779 eMatrix3d4x4.at = new_instancemethod(_enigma.eMatrix3d4x4_at, None, eMatrix3d4x4)
3780 eMatrix3d4x4_swigregister = _enigma.eMatrix3d4x4_swigregister
3781 eMatrix3d4x4_swigregister(eMatrix3d4x4)
3782
3783 class gRGBA(object):
3784     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3785     __repr__ = _swig_repr
3786     r = _swig_property(_enigma.gRGBA_r_get, _enigma.gRGBA_r_set)
3787     g = _swig_property(_enigma.gRGBA_g_get, _enigma.gRGBA_g_set)
3788     b = _swig_property(_enigma.gRGBA_b_get, _enigma.gRGBA_b_set)
3789     a = _swig_property(_enigma.gRGBA_a_get, _enigma.gRGBA_a_set)
3790
3791     def __init__(self, *args):
3792         """
3793         __init__(gRGBA self, unsigned int r, unsigned int g, unsigned int b, unsigned int a=0xff) -> gRGBA
3794         __init__(gRGBA self, unsigned int r, unsigned int g, unsigned int b) -> gRGBA
3795         __init__(gRGBA self) -> gRGBA
3796         """
3797         _enigma.gRGBA_swiginit(self, _enigma.new_gRGBA(*args))
3798
3799     def argb(self):
3800         """argb(gRGBA self) -> unsigned int"""
3801         return _enigma.gRGBA_argb(self)
3802
3803
3804     def fromArgb(c):
3805         """fromArgb(unsigned int c) -> gRGBA"""
3806         return _enigma.gRGBA_fromArgb(c)
3807
3808     fromArgb = staticmethod(fromArgb)
3809
3810     def __lt__(self, c):
3811         """__lt__(gRGBA self, gRGBA c) -> bool"""
3812         return _enigma.gRGBA___lt__(self, c)
3813
3814
3815     def __eq__(self, c):
3816         """__eq__(gRGBA self, gRGBA c) -> bool"""
3817         return _enigma.gRGBA___eq__(self, c)
3818
3819
3820     def __ne__(self, c):
3821         """__ne__(gRGBA self, gRGBA c) -> bool"""
3822         return _enigma.gRGBA___ne__(self, c)
3823
3824
3825     def premultiplyChannel(c, a):
3826         """premultiplyChannel(unsigned long c, unsigned long a) -> unsigned long"""
3827         return _enigma.gRGBA_premultiplyChannel(c, a)
3828
3829     premultiplyChannel = staticmethod(premultiplyChannel)
3830
3831     def premultiplyAlpha(self):
3832         """premultiplyAlpha(gRGBA self) -> gRGBA"""
3833         return _enigma.gRGBA_premultiplyAlpha(self)
3834
3835
3836     def set(self, *args):
3837         """
3838         set(gRGBA self, unsigned int _r, unsigned int _g, unsigned int _b)
3839         set(gRGBA self, unsigned int _r, unsigned int _g, unsigned int _b, unsigned int _a)
3840         """
3841         return _enigma.gRGBA_set(self, *args)
3842
3843
3844     def pixel(self, fmt):
3845         """pixel(gRGBA self, gPixelFormat fmt) -> unsigned int"""
3846         return _enigma.gRGBA_pixel(self, fmt)
3847
3848
3849     def fromPixel(self, fmt, pixel):
3850         """fromPixel(gRGBA self, gPixelFormat fmt, unsigned int pixel)"""
3851         return _enigma.gRGBA_fromPixel(self, fmt, pixel)
3852
3853     __swig_destroy__ = _enigma.delete_gRGBA
3854 gRGBA.argb = new_instancemethod(_enigma.gRGBA_argb, None, gRGBA)
3855 gRGBA.__lt__ = new_instancemethod(_enigma.gRGBA___lt__, None, gRGBA)
3856 gRGBA.__eq__ = new_instancemethod(_enigma.gRGBA___eq__, None, gRGBA)
3857 gRGBA.__ne__ = new_instancemethod(_enigma.gRGBA___ne__, None, gRGBA)
3858 gRGBA.premultiplyAlpha = new_instancemethod(_enigma.gRGBA_premultiplyAlpha, None, gRGBA)
3859 gRGBA.set = new_instancemethod(_enigma.gRGBA_set, None, gRGBA)
3860 gRGBA.pixel = new_instancemethod(_enigma.gRGBA_pixel, None, gRGBA)
3861 gRGBA.fromPixel = new_instancemethod(_enigma.gRGBA_fromPixel, None, gRGBA)
3862 gRGBA_swigregister = _enigma.gRGBA_swigregister
3863 gRGBA_swigregister(gRGBA)
3864
3865 def gRGBA_fromArgb(c):
3866     """gRGBA_fromArgb(unsigned int c) -> gRGBA"""
3867     return _enigma.gRGBA_fromArgb(c)
3868
3869 def gRGBA_premultiplyChannel(c, a):
3870     """gRGBA_premultiplyChannel(unsigned long c, unsigned long a) -> unsigned long"""
3871     return _enigma.gRGBA_premultiplyChannel(c, a)
3872
3873 class gRGB(gRGBA):
3874     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3875     __repr__ = _swig_repr
3876     a = _swig_property(_enigma.gRGB_a_get, _enigma.gRGB_a_set)
3877
3878     def __init__(self, *args):
3879         """
3880         __init__(gRGB self, int _r, int _g, int _b, int _a=0) -> gRGB
3881         __init__(gRGB self, int _r, int _g, int _b) -> gRGB
3882         __init__(gRGB self, unsigned int val) -> gRGB
3883         __init__(gRGB self) -> gRGB
3884         """
3885         _enigma.gRGB_swiginit(self, _enigma.new_gRGB(*args))
3886
3887     def argb(self):
3888         """argb(gRGB self) -> unsigned int"""
3889         return _enigma.gRGB_argb(self)
3890
3891     __swig_destroy__ = _enigma.delete_gRGB
3892 gRGB.argb = new_instancemethod(_enigma.gRGB_argb, None, gRGB)
3893 gRGB_swigregister = _enigma.gRGB_swigregister
3894 gRGB_swigregister(gRGB)
3895
3896 DISABLED = _enigma.DISABLED
3897 BILINEAR = _enigma.BILINEAR
3898 ANISOTROPIC = _enigma.ANISOTROPIC
3899 SHARP = _enigma.SHARP
3900 SHARPER = _enigma.SHARPER
3901 BLURRY = _enigma.BLURRY
3902 ANTI_FLUTTER = _enigma.ANTI_FLUTTER
3903 ANTI_FLUTTER_BLURRY = _enigma.ANTI_FLUTTER_BLURRY
3904 ANTI_FLUTTER_SHARP = _enigma.ANTI_FLUTTER_SHARP
3905 class iProgressInterpolator(object):
3906     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3907     __repr__ = _swig_repr
3908
3909     def __init__(self, *args):
3910         _enigma.iProgressInterpolator_swiginit(self, _enigma.new_iProgressInterpolator(*args))
3911     __swig_destroy__ = _enigma.delete_iProgressInterpolator
3912
3913     def at(self, progress):
3914         """at(iProgressInterpolator self, float progress) -> float"""
3915         return _enigma.iProgressInterpolator_at(self, progress)
3916
3917 iProgressInterpolator.__ref__ = new_instancemethod(_enigma.iProgressInterpolator___ref__, None, iProgressInterpolator)
3918 iProgressInterpolator.getPtrString = new_instancemethod(_enigma.iProgressInterpolator_getPtrString, None, iProgressInterpolator)
3919 iProgressInterpolator.__deref__ = new_instancemethod(_enigma.iProgressInterpolator___deref__, None, iProgressInterpolator)
3920 iProgressInterpolator.at = new_instancemethod(_enigma.iProgressInterpolator_at, None, iProgressInterpolator)
3921 iProgressInterpolator_swigregister = _enigma.iProgressInterpolator_swigregister
3922 iProgressInterpolator_swigregister(iProgressInterpolator)
3923
3924 class eLinearInterpolator(object):
3925     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3926     __repr__ = _swig_repr
3927
3928     def __init__(self, *args):
3929         _enigma.eLinearInterpolator_swiginit(self, _enigma.new_eLinearInterpolator(*args))
3930     __swig_destroy__ = _enigma.delete_eLinearInterpolator
3931     create = staticmethod(_enigma.eLinearInterpolator_create)
3932
3933     def at(self, progress):
3934         """at(eLinearInterpolator self, float progress) -> float"""
3935         return _enigma.eLinearInterpolator_at(self, progress)
3936
3937 eLinearInterpolator.__ref__ = new_instancemethod(_enigma.eLinearInterpolator___ref__, None, eLinearInterpolator)
3938 eLinearInterpolator.getPtrString = new_instancemethod(_enigma.eLinearInterpolator_getPtrString, None, eLinearInterpolator)
3939 eLinearInterpolator.__deref__ = new_instancemethod(_enigma.eLinearInterpolator___deref__, None, eLinearInterpolator)
3940 eLinearInterpolator.at = new_instancemethod(_enigma.eLinearInterpolator_at, None, eLinearInterpolator)
3941 eLinearInterpolator_swigregister = _enigma.eLinearInterpolator_swigregister
3942 eLinearInterpolator_swigregister(eLinearInterpolator)
3943
3944 def eLinearInterpolator_create():
3945     return _enigma.eLinearInterpolator_create()
3946 eLinearInterpolator_create = _enigma.eLinearInterpolator_create
3947
3948 class eAcclerateInterpolator(object):
3949     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3950     __repr__ = _swig_repr
3951
3952     def __init__(self, *args):
3953         _enigma.eAcclerateInterpolator_swiginit(self, _enigma.new_eAcclerateInterpolator(*args))
3954     __swig_destroy__ = _enigma.delete_eAcclerateInterpolator
3955     create = staticmethod(_enigma.eAcclerateInterpolator_create)
3956
3957     def at(self, progress):
3958         """at(eAcclerateInterpolator self, float progress) -> float"""
3959         return _enigma.eAcclerateInterpolator_at(self, progress)
3960
3961 eAcclerateInterpolator.__ref__ = new_instancemethod(_enigma.eAcclerateInterpolator___ref__, None, eAcclerateInterpolator)
3962 eAcclerateInterpolator.getPtrString = new_instancemethod(_enigma.eAcclerateInterpolator_getPtrString, None, eAcclerateInterpolator)
3963 eAcclerateInterpolator.__deref__ = new_instancemethod(_enigma.eAcclerateInterpolator___deref__, None, eAcclerateInterpolator)
3964 eAcclerateInterpolator.at = new_instancemethod(_enigma.eAcclerateInterpolator_at, None, eAcclerateInterpolator)
3965 eAcclerateInterpolator_swigregister = _enigma.eAcclerateInterpolator_swigregister
3966 eAcclerateInterpolator_swigregister(eAcclerateInterpolator)
3967
3968 def eAcclerateInterpolator_create(factor=1.0):
3969     return _enigma.eAcclerateInterpolator_create(factor)
3970 eAcclerateInterpolator_create = _enigma.eAcclerateInterpolator_create
3971
3972 class eDecelerateInterpolator(object):
3973     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3974     __repr__ = _swig_repr
3975
3976     def __init__(self, *args):
3977         _enigma.eDecelerateInterpolator_swiginit(self, _enigma.new_eDecelerateInterpolator(*args))
3978     __swig_destroy__ = _enigma.delete_eDecelerateInterpolator
3979     create = staticmethod(_enigma.eDecelerateInterpolator_create)
3980
3981     def at(self, progress):
3982         """at(eDecelerateInterpolator self, float progress) -> float"""
3983         return _enigma.eDecelerateInterpolator_at(self, progress)
3984
3985 eDecelerateInterpolator.__ref__ = new_instancemethod(_enigma.eDecelerateInterpolator___ref__, None, eDecelerateInterpolator)
3986 eDecelerateInterpolator.getPtrString = new_instancemethod(_enigma.eDecelerateInterpolator_getPtrString, None, eDecelerateInterpolator)
3987 eDecelerateInterpolator.__deref__ = new_instancemethod(_enigma.eDecelerateInterpolator___deref__, None, eDecelerateInterpolator)
3988 eDecelerateInterpolator.at = new_instancemethod(_enigma.eDecelerateInterpolator_at, None, eDecelerateInterpolator)
3989 eDecelerateInterpolator_swigregister = _enigma.eDecelerateInterpolator_swigregister
3990 eDecelerateInterpolator_swigregister(eDecelerateInterpolator)
3991
3992 def eDecelerateInterpolator_create(factor=1.0):
3993     return _enigma.eDecelerateInterpolator_create(factor)
3994 eDecelerateInterpolator_create = _enigma.eDecelerateInterpolator_create
3995
3996 class eOvershootInterpolator(object):
3997     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3998     __repr__ = _swig_repr
3999
4000     def __init__(self, *args):
4001         _enigma.eOvershootInterpolator_swiginit(self, _enigma.new_eOvershootInterpolator(*args))
4002     __swig_destroy__ = _enigma.delete_eOvershootInterpolator
4003     create = staticmethod(_enigma.eOvershootInterpolator_create)
4004
4005     def at(self, progress):
4006         """at(eOvershootInterpolator self, float progress) -> float"""
4007         return _enigma.eOvershootInterpolator_at(self, progress)
4008
4009 eOvershootInterpolator.__ref__ = new_instancemethod(_enigma.eOvershootInterpolator___ref__, None, eOvershootInterpolator)
4010 eOvershootInterpolator.getPtrString = new_instancemethod(_enigma.eOvershootInterpolator_getPtrString, None, eOvershootInterpolator)
4011 eOvershootInterpolator.__deref__ = new_instancemethod(_enigma.eOvershootInterpolator___deref__, None, eOvershootInterpolator)
4012 eOvershootInterpolator.at = new_instancemethod(_enigma.eOvershootInterpolator_at, None, eOvershootInterpolator)
4013 eOvershootInterpolator_swigregister = _enigma.eOvershootInterpolator_swigregister
4014 eOvershootInterpolator_swigregister(eOvershootInterpolator)
4015
4016 def eOvershootInterpolator_create(tension=2.0):
4017     return _enigma.eOvershootInterpolator_create(tension)
4018 eOvershootInterpolator_create = _enigma.eOvershootInterpolator_create
4019
4020 class eBounceInterpolator(object):
4021     thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4022     __repr__ = _swig_repr
4023
4024     def __init__(self, *args):
4025         _enigma.eBounceInterpolator_swiginit(self, _enigma.new_eBounceInterpolator(*args))
4026     __swig_destroy__ = _enigma.delete_eBounceInterpolator
4027     create = staticmethod(_enigma.eBounceInterpolator_create)
4028
4029     def at(self, progress):
4030         """at(eBounceInterpolator self, float progress) -> float"""
4031         return _enigma.eBounceInterpolator_at(self, progress)
4032
4033 eBounceInterpolator.__ref__ = new_instancemethod(_enigma.eBounceInterpolator___ref__, None, eBounceInterpolator)
4034 eBounceInterpolator.getPtrString = new_instancemethod(_enigma.eBounceInterpolator_getPtrString, None, eBounceInterpolator)
4035 eBounceInterpolator.__deref__ = new_instancemethod(_enigma.eBounceInterpolator___deref__, None, eBounceInterpolator)
4036 eBounceInterpolator.at = new_instancemethod(_enigma.eBounceInterpolator_at, None, eBounceInterpolator)
4037 eBounceInterpolator_swigregister = _enigma.eBounceInterpolator_swigregister
4038 eBounceInterpolator_swigregister(eBounceInterpolator)
4039
4040 def eBounceInterpolator_create():
4041     return _enigma.eBounceInterpolator_create()
4042 eBounceInterpolator_create = _enigma.eBounceInterpolator_create