RecordTimer.py,RecordingConfig.py,setup.xml: *add possibility to change the default...
[enigma2.git] / lib / base / ebase.cpp
1 #include <lib/base/ebase.h>
2
3 #include <fcntl.h>
4 #include <unistd.h>
5 #include <errno.h>
6
7 #include <lib/base/eerror.h>
8 #include <lib/base/elock.h>
9 #include <lib/gdi/grc.h>
10
11 DEFINE_REF(eSocketNotifier);
12
13 eSocketNotifier::eSocketNotifier(eMainloop *context, int fd, int requested, bool startnow): context(*context), fd(fd), state(0), requested(requested)
14 {
15         if (startnow)
16                 start();
17 }
18
19 eSocketNotifier::~eSocketNotifier()
20 {
21         stop();
22 }
23
24 void eSocketNotifier::start()
25 {
26         if (state)
27                 stop();
28
29         context.addSocketNotifier(this);
30         state=2;  // running but not in poll yet
31 }
32
33 void eSocketNotifier::stop()
34 {
35         if (state)
36         {
37                 state=0;
38                 context.removeSocketNotifier(this);
39         }
40 }
41
42 DEFINE_REF(eTimer);
43
44 void eTimer::start(long msek, bool singleShot)
45 {
46         if (bActive)
47                 stop();
48
49         bActive = true;
50         bSingleShot = singleShot;
51         interval = msek;
52         clock_gettime(CLOCK_MONOTONIC, &nextActivation);
53 //      eDebug("this = %p\nnow sec = %d, nsec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_nsec, msek);
54         nextActivation += (msek<0 ? 0 : msek);
55 //      eDebug("next Activation sec = %d, nsec = %d", nextActivation.tv_sec, nextActivation.tv_nsec );
56         context.addTimer(this);
57 }
58
59 void eTimer::startLongTimer( int seconds )
60 {
61         if (bActive)
62                 stop();
63
64         bActive = bSingleShot = true;
65         interval = 0;
66         clock_gettime(CLOCK_MONOTONIC, &nextActivation);
67 //      eDebug("this = %p\nnow sec = %d, nsec = %d\nadd %d sec", this, nextActivation.tv_sec, nextActivation.tv_nsec, seconds);
68         if ( seconds > 0 )
69                 nextActivation.tv_sec += seconds;
70 //      eDebug("next Activation sec = %d, nsec = %d", nextActivation.tv_sec, nextActivation.tv_nsec );
71         context.addTimer(this);
72 }
73
74 void eTimer::stop()
75 {
76         if (bActive)
77         {
78                 bActive=false;
79                 context.removeTimer(this);
80         }
81 }
82
83 void eTimer::changeInterval(long msek)
84 {
85         if (bActive)  // Timer is running?
86         {
87                 context.removeTimer(this);       // then stop
88                 nextActivation -= interval;  // sub old interval
89         }
90         else
91                 bActive=true; // then activate Timer
92
93         interval = msek;                                                // set new Interval
94         nextActivation += interval;             // calc nextActivation
95
96         context.addTimer(this);                         // add Timer to context TimerList
97 }
98
99 void eTimer::activate()   // Internal Funktion... called from eApplication
100 {
101         context.removeTimer(this);
102
103         if (!bSingleShot)
104         {
105                 nextActivation += interval;
106                 context.addTimer(this);
107         }
108         else
109                 bActive=false;
110
111         /*emit*/ timeout();
112 }
113
114 // mainloop
115 ePtrList<eMainloop> eMainloop::existing_loops;
116
117 eMainloop::~eMainloop()
118 {
119         existing_loops.remove(this);
120         for (std::map<int, eSocketNotifier*>::iterator it(notifiers.begin());it != notifiers.end();++it)
121                 it->second->stop();
122         while(m_timer_list.begin() != m_timer_list.end())
123                 m_timer_list.begin()->stop();
124 }
125
126 void eMainloop::addSocketNotifier(eSocketNotifier *sn)
127 {
128         int fd = sn->getFD();
129         if (m_inActivate && m_inActivate->ref.count == 1)
130         {
131                 /*  when the current active SocketNotifier's refcount is one,
132                         then no more external references are existing.
133                         So it gets destroyed when the activate callback is finished (->AddRef() / ->Release() calls in processOneEvent).
134                         But then the sn->stop() is called to late for the next Asserion.
135                         Thus we call sn->stop() here (this implicitly calls eMainloop::removeSocketNotifier) and we don't get trouble
136                         with the next Assertion.
137                 */
138                 m_inActivate->stop();
139         }
140         ASSERT(notifiers.find(fd) == notifiers.end());
141         notifiers[fd]=sn;
142 }
143
144 void eMainloop::removeSocketNotifier(eSocketNotifier *sn)
145 {
146         int fd = sn->getFD();
147         std::map<int,eSocketNotifier*>::iterator i(notifiers.find(fd));
148         if (i != notifiers.end())
149         {
150                 notifiers.erase(i);
151                 return;
152         }
153         for (i = notifiers.begin(); i != notifiers.end(); ++i)
154                 eDebug("fd=%d, sn=%d", i->second->getFD(), (void*)i->second);
155         eFatal("removed socket notifier which is not present, fd=%d", fd);
156 }
157
158 int eMainloop::processOneEvent(unsigned int twisted_timeout, PyObject **res, ePyObject additional)
159 {
160         int return_reason = 0;
161                 /* get current time */
162
163         if (additional && !PyDict_Check(additional))
164                 eFatal("additional, but it's not dict");
165
166         if (additional && !res)
167                 eFatal("additional, but no res");
168
169         long poll_timeout = -1; /* infinite in case of empty timer list */
170
171         if (!m_timer_list.empty())
172         {
173                 /* process all timers which are ready. first remove them out of the list. */
174                 while (!m_timer_list.empty() && (poll_timeout = timeout_usec( m_timer_list.begin()->getNextActivation() ) ) <= 0 )
175                 {
176                         eTimer *tmr = m_timer_list.begin();
177                         tmr->AddRef();
178                         tmr->activate();
179                         tmr->Release();
180                 }
181                 if (poll_timeout < 0)
182                         poll_timeout = 0;
183                 else /* convert us to ms */
184                         poll_timeout /= 1000;
185         }
186
187         if ((twisted_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > twisted_timeout))
188         {
189                 poll_timeout = twisted_timeout;
190                 return_reason = 1;
191         }
192
193         int nativecount=notifiers.size(),
194                 fdcount=nativecount,
195                 ret=0;
196
197         if (additional)
198                 fdcount += PyDict_Size(additional);
199
200                 // build the poll aray
201         pollfd pfd[fdcount];  // make new pollfd array
202         std::map<int,eSocketNotifier*>::iterator it = notifiers.begin();
203
204         int i=0;
205         for (; i < nativecount; ++i, ++it)
206         {
207                 it->second->state = 1; // running and in poll
208                 pfd[i].fd = it->first;
209                 pfd[i].events = it->second->getRequested();
210         }
211
212         if (additional)
213         {
214 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
215                 typedef int Py_ssize_t;
216 # define PY_SSIZE_T_MAX INT_MAX
217 # define PY_SSIZE_T_MIN INT_MIN
218 #endif
219                 PyObject *key, *val;
220                 Py_ssize_t pos=0;
221                 while (PyDict_Next(additional, &pos, &key, &val)) {
222                         pfd[i].fd = PyObject_AsFileDescriptor(key);
223                         pfd[i++].events = PyInt_AsLong(val);
224                 }
225         }
226
227         m_is_idle = 1;
228         ++m_idle_count;
229
230         if (this == eApp)
231         {
232                 gOpcode op;
233                 op.dc = 0;
234                 op.opcode = gOpcode::flush;
235                 gRC::getInstance()->submit(op);
236                 Py_BEGIN_ALLOW_THREADS
237                 ret = ::poll(pfd, fdcount, poll_timeout);
238                 Py_END_ALLOW_THREADS
239                 
240         } else
241                 ret = ::poll(pfd, fdcount, poll_timeout);
242
243         m_is_idle = 0;
244
245                         /* ret > 0 means that there are some active poll entries. */
246         if (ret > 0)
247         {
248                 int i=0;
249                 return_reason = 0;
250                 for (; i < nativecount; ++i)
251                 {
252                         if (pfd[i].revents)
253                         {
254                                 it = notifiers.find(pfd[i].fd);
255                                 if (it != notifiers.end()
256                                         && it->second->state == 1) // added and in poll
257                                 {
258                                         m_inActivate = it->second;
259                                         int req = m_inActivate->getRequested();
260                                         if (pfd[i].revents & req) {
261                                                 m_inActivate->AddRef();
262                                                 m_inActivate->activate(pfd[i].revents & req);
263                                                 m_inActivate->Release();
264                                         }
265                                         pfd[i].revents &= ~req;
266                                         m_inActivate = 0;
267                                 }
268                                 if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL))
269                                         eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd, pfd[i].revents);
270                         }
271                 }
272                 for (; i < fdcount; ++i)
273                 {
274                         if (pfd[i].revents)
275                         {
276                                 if (!*res)
277                                         *res = PyList_New(0);
278                                 ePyObject it = PyTuple_New(2);
279                                 PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd));
280                                 PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents));
281                                 PyList_Append(*res, it);
282                                 Py_DECREF(it);
283                         }
284                 }
285         }
286         else if (ret < 0)
287         {
288                         /* when we got a signal, we get EINTR. */
289                 if (errno != EINTR)
290                         eDebug("poll made error (%m)");
291                 else
292                         return_reason = 2; /* don't assume the timeout has passed when we got a signal */
293         }
294
295         return return_reason;
296 }
297
298 void eMainloop::addTimer(eTimer* e)
299 {
300         m_timer_list.insert_in_order(e);
301 }
302
303 void eMainloop::removeTimer(eTimer* e)
304 {
305         m_timer_list.remove(e);
306 }
307
308 int eMainloop::iterate(unsigned int twisted_timeout, PyObject **res, ePyObject dict)
309 {
310         int ret = 0;
311
312         if (twisted_timeout)
313         {
314                 clock_gettime(CLOCK_MONOTONIC, &m_twisted_timer);
315                 m_twisted_timer += twisted_timeout;
316         }
317
318                 /* TODO: this code just became ugly. fix that. */
319         do
320         {
321                 if (m_interrupt_requested)
322                 {
323                         m_interrupt_requested = 0;
324                         return 0;
325                 }
326
327                 if (app_quit_now)
328                         return -1;
329
330                 int to = 0;
331                 if (twisted_timeout)
332                 {
333                         timespec now, timeout;
334                         clock_gettime(CLOCK_MONOTONIC, &now);
335                         if (m_twisted_timer<=now) // timeout
336                                 return 0;
337                         timeout = m_twisted_timer - now;
338                         to = timeout.tv_sec * 1000 + timeout.tv_nsec / 1000000;
339                 }
340                 ret = processOneEvent(to, res, dict);
341         } while ( !ret && !(res && *res) );
342
343         return ret;
344 }
345
346 int eMainloop::runLoop()
347 {
348         while (!app_quit_now)
349                 iterate();
350         return retval;
351 }
352
353 void eMainloop::reset()
354 {
355         app_quit_now=false;
356 }
357
358 PyObject *eMainloop::poll(ePyObject timeout, ePyObject dict)
359 {
360         PyObject *res=0;
361
362         if (app_quit_now)
363                 Py_RETURN_NONE;
364
365         int twisted_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout);
366
367         iterate(twisted_timeout, &res, dict);
368         if (res)
369                 return res;
370
371         return PyList_New(0); /* return empty list on timeout */
372 }
373
374 void eMainloop::interruptPoll()
375 {
376         m_interrupt_requested = 1;
377 }
378
379 void eMainloop::quit(int ret)
380 {
381         retval = ret;
382         app_quit_now = true;
383 }
384
385 eApplication* eApp = 0;
386
387 #include "structmember.h"
388
389 extern "C" {
390
391 // eTimer replacement
392
393 struct eTimerPy
394 {
395         PyObject_HEAD
396         eTimer *tm;
397         PyObject *in_weakreflist; /* List of weak references */
398 };
399
400 static int
401 eTimerPy_traverse(eTimerPy *self, visitproc visit, void *arg)
402 {
403         PyObject *obj = self->tm->timeout.getSteal();
404         if (obj) {
405                 Py_VISIT(obj);
406         }
407         return 0;
408 }
409
410 static int
411 eTimerPy_clear(eTimerPy *self)
412 {
413         PyObject *obj = self->tm->timeout.getSteal(true);
414         if (obj)
415                 Py_CLEAR(obj);
416         return 0;
417 }
418
419 static void
420 eTimerPy_dealloc(eTimerPy* self)
421 {
422         if (self->in_weakreflist != NULL)
423                 PyObject_ClearWeakRefs((PyObject *) self);
424         eTimerPy_clear(self);
425         self->tm->Release();
426         self->ob_type->tp_free((PyObject*)self);
427 }
428
429 static PyObject *
430 eTimerPy_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
431 {
432         eTimerPy *self = (eTimerPy *)type->tp_alloc(type, 0);
433         self->tm = eTimer::create(eApp);
434         self->tm->AddRef();
435         self->in_weakreflist = NULL;
436         return (PyObject *)self;
437 }
438
439 static PyObject *
440 eTimerPy_is_active(eTimerPy* self)
441 {
442         PyObject *ret = NULL;
443         ret = self->tm->isActive() ? Py_True : Py_False;
444         Org_Py_INCREF(ret);
445         return ret;
446 }
447
448 static PyObject *
449 eTimerPy_start(eTimerPy* self, PyObject *args)
450 {
451         long v=0;
452         long singleShot=0;
453         if (PyTuple_Size(args) > 1)
454         {
455                 if (!PyArg_ParseTuple(args, "ll", &v, &singleShot)) // when 2nd arg is a value
456                 {
457                         PyObject *obj=0;
458                         if (!PyArg_ParseTuple(args, "lO", &v, &obj)) // get 2nd arg as python object
459                                 return NULL;
460                         else if (obj == Py_True)
461                                 singleShot=1;
462                         else if (obj != Py_False)
463                                 return NULL;
464                 }
465         }
466         else if (!PyArg_ParseTuple(args, "l", &v))
467                 return NULL;
468         self->tm->start(v, singleShot);
469         Py_RETURN_NONE;
470 }
471
472 static PyObject *
473 eTimerPy_start_long(eTimerPy* self, PyObject *args)
474 {
475         int v=0;
476         if (!PyArg_ParseTuple(args, "i", &v)) {
477                 return NULL;
478         }
479         self->tm->startLongTimer(v);
480         Py_RETURN_NONE;
481 }
482
483 static PyObject *
484 eTimerPy_change_interval(eTimerPy* self, PyObject *args)
485 {
486         long v=0;
487         if (!PyArg_ParseTuple(args, "l", &v)) {
488                 return NULL;
489         }
490         self->tm->changeInterval(v);
491         Py_RETURN_NONE;
492 }
493
494 static PyObject *
495 eTimerPy_stop(eTimerPy* self)
496 {
497         self->tm->stop();
498         Py_RETURN_NONE;
499 }
500
501 static PyObject *
502 eTimerPy_get_callback_list(eTimerPy *self)
503 { //used for compatibilty with the old eTimer
504         return self->tm->timeout.get();
505 }
506
507 static PyMethodDef eTimerPy_methods[] = {
508         {"isActive", (PyCFunction)eTimerPy_is_active, METH_NOARGS,
509          "returns the timer state"
510         },
511         {"start", (PyCFunction)eTimerPy_start, METH_VARARGS,
512          "start timer with interval in msecs"
513         },
514         {"startLongTimer", (PyCFunction)eTimerPy_start_long, METH_VARARGS,
515          "start timer with interval in secs"
516         },
517         {"changeInterval", (PyCFunction)eTimerPy_change_interval, METH_VARARGS,
518          "change interval of a timer (in msecs)"
519         },
520         {"stop", (PyCFunction)eTimerPy_stop, METH_NOARGS,
521          "stops the timer"
522         },
523         //used for compatibilty with the old eTimer
524         {"get", (PyCFunction)eTimerPy_get_callback_list, METH_NOARGS,
525          "get timeout callback list"
526         },
527         {NULL}  /* Sentinel */
528 };
529
530 static PyObject *
531 eTimerPy_get_cb_list(eTimerPy *self, void *closure)
532 {
533         return self->tm->timeout.get();
534 }
535
536 static PyObject *
537 eTimerPy_timeout(eTimerPy *self, void *closure) 
538 { //used for compatibilty with the old eTimer
539         Org_Py_INCREF((PyObject*)self);
540         return (PyObject*)self;
541 }
542
543 static PyGetSetDef eTimerPy_getseters[] = {
544         {"callback",
545          (getter)eTimerPy_get_cb_list, (setter)0,
546          "returns the callback python list",
547          NULL},
548
549         {"timeout", //used for compatibilty with the old eTimer
550          (getter)eTimerPy_timeout, (setter)0,
551          "synonym for our self",
552          NULL},
553
554         {NULL} /* Sentinel */
555 };
556
557 static PyTypeObject eTimerPyType = {
558         PyObject_HEAD_INIT(NULL)
559         0, /*ob_size*/
560         "eBaseImpl.eTimer", /*tp_name*/
561         sizeof(eTimerPy), /*tp_basicsize*/
562         0, /*tp_itemsize*/
563         (destructor)eTimerPy_dealloc, /*tp_dealloc*/
564         0, /*tp_print*/
565         0, /*tp_getattr*/
566         0, /*tp_setattr*/
567         0, /*tp_compare*/
568         0, /*tp_repr*/
569         0, /*tp_as_number*/
570         0, /*tp_as_sequence*/
571         0, /*tp_as_mapping*/
572         0, /*tp_hash */
573         0, /*tp_call*/
574         0, /*tp_str*/
575         0, /*tp_getattro*/
576         0, /*tp_setattro*/
577         0, /*tp_as_buffer*/
578         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
579         "eTimer objects", /* tp_doc */
580         (traverseproc)eTimerPy_traverse, /* tp_traverse */
581         (inquiry)eTimerPy_clear, /* tp_clear */
582         0, /* tp_richcompare */
583         offsetof(eTimerPy, in_weakreflist), /* tp_weaklistoffset */
584         0, /* tp_iter */
585         0, /* tp_iternext */
586         eTimerPy_methods, /* tp_methods */
587         0, /* tp_members */
588         eTimerPy_getseters, /* tp_getset */
589         0, /* tp_base */
590         0, /* tp_dict */
591         0, /* tp_descr_get */
592         0, /* tp_descr_set */
593         0, /* tp_dictoffset */
594         0, /* tp_init */
595         0, /* tp_alloc */
596         eTimerPy_new, /* tp_new */
597 };
598
599 // eSocketNotifier replacement
600
601 struct eSocketNotifierPy
602 {
603         PyObject_HEAD
604         eSocketNotifier *sn;
605         PyObject *in_weakreflist; /* List of weak references */
606 };
607
608 static int
609 eSocketNotifierPy_traverse(eSocketNotifierPy *self, visitproc visit, void *arg)
610 {
611         PyObject *obj = self->sn->activated.getSteal();
612         if (obj)
613                 Py_VISIT(obj);
614         return 0;
615 }
616
617 static int
618 eSocketNotifierPy_clear(eSocketNotifierPy *self)
619 {
620         PyObject *obj = self->sn->activated.getSteal(true);
621         if (obj)
622                 Py_CLEAR(obj);
623         return 0;
624 }
625
626 static void
627 eSocketNotifierPy_dealloc(eSocketNotifierPy* self)
628 {
629         if (self->in_weakreflist != NULL)
630                 PyObject_ClearWeakRefs((PyObject *) self);
631         eSocketNotifierPy_clear(self);
632         self->sn->Release();
633         self->ob_type->tp_free((PyObject*)self);
634 }
635
636 static PyObject *
637 eSocketNotifierPy_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
638 {
639         eSocketNotifierPy *self = (eSocketNotifierPy *)type->tp_alloc(type, 0);
640         int fd, req, immediate_start = 1, size = PyTuple_Size(args);
641         if (size > 2)
642         {
643                 if (!PyArg_ParseTuple(args, "iii", &fd, &req, &immediate_start))
644                 {
645                         PyObject *obj = NULL;
646                         if (!PyArg_ParseTuple(args, "iiO", &fd, &req, &immediate_start))
647                                 return NULL;
648                         if (obj == Py_False)
649                                 immediate_start = 0;
650                         else if (obj != Py_True)
651                                 return NULL;
652                 }
653         }
654         else if (size < 2 || !PyArg_ParseTuple(args, "ii", &fd, &req))
655                 return NULL;
656         self->sn = eSocketNotifier::create(eApp, fd, req, immediate_start);
657         self->sn->AddRef();
658         self->in_weakreflist = NULL;
659         return (PyObject *)self;
660 }
661
662 static PyObject *
663 eSocketNotifierPy_is_running(eSocketNotifierPy* self)
664 {
665         PyObject *ret = self->sn->isRunning() ? Py_True : Py_False;
666         Org_Py_INCREF(ret);
667         return ret;
668 }
669
670 static PyObject *
671 eSocketNotifierPy_start(eSocketNotifierPy* self)
672 {
673         self->sn->start();
674         Py_RETURN_NONE;
675 }
676
677 static PyObject *
678 eSocketNotifierPy_stop(eSocketNotifierPy* self)
679 {
680         self->sn->stop();
681         Py_RETURN_NONE;
682 }
683
684 static PyObject *
685 eSocketNotifierPy_get_fd(eSocketNotifierPy* self)
686 {
687         return PyInt_FromLong(self->sn->getFD());
688 }
689
690 static PyObject *
691 eSocketNotifierPy_get_requested(eSocketNotifierPy* self)
692 {
693         return PyInt_FromLong(self->sn->getRequested());
694 }
695
696 static PyObject *
697 eSocketNotifierPy_set_requested(eSocketNotifierPy* self, PyObject *args)
698 {
699         int req;
700         if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &req))
701                 return NULL;
702         self->sn->setRequested(req);
703         Py_RETURN_NONE;
704 }
705
706 static PyMethodDef eSocketNotifierPy_methods[] = {
707         {"isRunning", (PyCFunction)eSocketNotifierPy_is_running, METH_NOARGS,
708          "returns the running state"
709         },
710         {"start", (PyCFunction)eSocketNotifierPy_start, METH_NOARGS,
711          "start the sn"
712         },
713         {"stop", (PyCFunction)eSocketNotifierPy_stop, METH_NOARGS,
714          "stops the sn"
715         },
716         {"getFD", (PyCFunction)eSocketNotifierPy_get_fd, METH_NOARGS,
717          "get file descriptor"
718         },
719         {"getRequested", (PyCFunction)eSocketNotifierPy_get_requested, METH_NOARGS,
720          "get requested"
721         },
722         {"setRequested", (PyCFunction)eSocketNotifierPy_set_requested, METH_VARARGS,
723          "set requested"
724         },
725         {NULL}  /* Sentinel */
726 };
727
728 static PyObject *
729 eSocketNotifierPy_get_cb_list(eSocketNotifierPy *self, void *closure)
730 {
731         return self->sn->activated.get();
732 }
733
734 static PyGetSetDef eSocketNotifierPy_getseters[] = {
735         {"callback",
736          (getter)eSocketNotifierPy_get_cb_list, (setter)0,
737          "returns the callback python list",
738          NULL},
739         {NULL} /* Sentinel */
740 };
741
742 static PyTypeObject eSocketNotifierPyType = {
743         PyObject_HEAD_INIT(NULL)
744         0, /*ob_size*/
745         "eBaseImpl.eSocketNotifier", /*tp_name*/
746         sizeof(eSocketNotifierPy), /*tp_basicsize*/
747         0, /*tp_itemsize*/
748         (destructor)eSocketNotifierPy_dealloc, /*tp_dealloc*/
749         0, /*tp_print*/
750         0, /*tp_getattr*/
751         0, /*tp_setattr*/
752         0, /*tp_compare*/
753         0, /*tp_repr*/
754         0, /*tp_as_number*/
755         0, /*tp_as_sequence*/
756         0, /*tp_as_mapping*/
757         0, /*tp_hash */
758         0, /*tp_call*/
759         0, /*tp_str*/
760         0, /*tp_getattro*/
761         0, /*tp_setattro*/
762         0, /*tp_as_buffer*/
763         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
764         "eTimer objects", /* tp_doc */
765         (traverseproc)eSocketNotifierPy_traverse, /* tp_traverse */
766         (inquiry)eSocketNotifierPy_clear, /* tp_clear */
767         0, /* tp_richcompare */
768         offsetof(eSocketNotifierPy, in_weakreflist), /* tp_weaklistoffset */
769         0, /* tp_iter */
770         0, /* tp_iternext */
771         eSocketNotifierPy_methods, /* tp_methods */
772         0, /* tp_members */
773         eSocketNotifierPy_getseters, /* tp_getset */
774         0, /* tp_base */
775         0, /* tp_dict */
776         0, /* tp_descr_get */
777         0, /* tp_descr_set */
778         0, /* tp_dictoffset */
779         0, /* tp_init */
780         0, /* tp_alloc */
781         eSocketNotifierPy_new, /* tp_new */
782 };
783
784 static PyMethodDef module_methods[] = {
785         {NULL}  /* Sentinel */
786 };
787
788 void eBaseInit(void)
789 {
790         PyObject* m = Py_InitModule3("eBaseImpl", module_methods,
791                 "Module that implements some enigma classes with working cyclic garbage collection.");
792
793         if (m == NULL)
794                 return;
795
796         if (!PyType_Ready(&eTimerPyType))
797         {
798                 Org_Py_INCREF((PyObject*)&eTimerPyType);
799                 PyModule_AddObject(m, "eTimer", (PyObject*)&eTimerPyType);
800         }
801         if (!PyType_Ready(&eSocketNotifierPyType))
802         {
803                 Org_Py_INCREF((PyObject*)&eSocketNotifierPyType);
804                 PyModule_AddObject(m, "eSocketNotifier", (PyObject*)&eSocketNotifierPyType);
805         }
806 }
807 }