remove lib/content
[enigma2.git] / lib / base / ebase.h
1 #ifndef __ebase_h
2 #define __ebase_h
3
4 #include <vector>
5 #include <map>
6 #include <sys/poll.h>
7 #include <sys/time.h>
8 #include <asm/types.h>
9 #include <time.h>
10
11 #include <lib/base/eptrlist.h>
12 #include <lib/python/connections.h>
13 #include <libsig_comp.h>
14
15 class eApplication;
16
17 extern eApplication* eApp;
18
19 static inline bool operator<( const timeval &t1, const timeval &t2 )
20 {
21         return t1.tv_sec < t2.tv_sec || (t1.tv_sec == t2.tv_sec && t1.tv_usec < t2.tv_usec);
22 }
23
24 static inline timeval &operator+=( timeval &t1, const timeval &t2 )
25 {
26         t1.tv_sec += t2.tv_sec;
27         if ( (t1.tv_usec += t2.tv_usec) >= 1000000 )
28         {
29                 t1.tv_sec++;
30                 t1.tv_usec -= 1000000;
31         }
32         return t1;
33 }
34
35 static inline timeval operator+( const timeval &t1, const timeval &t2 )
36 {
37         timeval tmp;
38         tmp.tv_sec = t1.tv_sec + t2.tv_sec;
39         if ( (tmp.tv_usec = t1.tv_usec + t2.tv_usec) >= 1000000 )
40         {
41                 tmp.tv_sec++;
42                 tmp.tv_usec -= 1000000;
43         }
44         return tmp;
45 }
46
47 static inline timeval operator-( const timeval &t1, const timeval &t2 )
48 {
49         timeval tmp;
50         tmp.tv_sec = t1.tv_sec - t2.tv_sec;
51         if ( (tmp.tv_usec = t1.tv_usec - t2.tv_usec) < 0 )
52         {
53                 tmp.tv_sec--;
54                 tmp.tv_usec += 1000000;
55         }
56         return tmp;
57 }
58
59 static inline timeval operator-=( timeval &t1, const timeval &t2 )
60 {
61         t1.tv_sec -= t2.tv_sec;
62         if ( (t1.tv_usec -= t2.tv_usec) < 0 )
63         {
64                 t1.tv_sec--;
65                 t1.tv_usec += 1000000;
66         }
67         return t1;
68 }
69
70 static inline timeval &operator+=( timeval &t1, const long msek )
71 {
72         t1.tv_sec += msek / 1000;
73         if ( (t1.tv_usec += (msek % 1000) * 1000) >= 1000000 )
74         {
75                 t1.tv_sec++;
76                 t1.tv_usec -= 1000000;
77         }
78         return t1;
79 }
80
81 static inline timeval operator+( const timeval &t1, const long msek )
82 {
83         timeval tmp;
84         tmp.tv_sec = t1.tv_sec + msek / 1000;
85         if ( (tmp.tv_usec = t1.tv_usec + (msek % 1000) * 1000) >= 1000000 )
86         {
87                 tmp.tv_sec++;
88                 tmp.tv_usec -= 1000000;
89         }
90         return tmp;
91 }
92
93 static inline timeval operator-( const timeval &t1, const long msek )
94 {
95         timeval tmp;
96         tmp.tv_sec = t1.tv_sec - msek / 1000;
97         if ( (tmp.tv_usec = t1.tv_usec - (msek % 1000)*1000) < 0 )
98         {
99                 tmp.tv_sec--;
100                 tmp.tv_usec += 1000000;
101         }
102         return tmp;
103 }
104
105 static inline timeval operator-=( timeval &t1, const long msek )
106 {
107         t1.tv_sec -= msek / 1000;
108         if ( (t1.tv_usec -= (msek % 1000) * 1000) < 0 )
109         {
110                 t1.tv_sec--;
111                 t1.tv_usec += 1000000;
112         }
113         return t1;
114 }
115
116 static inline timeval timeout_timeval ( const timeval & orig )
117 {
118         timeval now;
119   gettimeofday(&now,0);
120
121         return orig-now;
122 }
123
124 static inline long timeout_usec ( const timeval & orig )
125 {
126         timeval now;
127   gettimeofday(&now,0);
128
129         return (orig-now).tv_sec*1000000 + (orig-now).tv_usec;
130 }
131
132 class eMainloop;
133
134                                         // die beiden signalquellen: SocketNotifier...
135
136 /**
137  * \brief Gives a callback when data on a file descriptor is ready.
138  *
139  * This class emits the signal \c eSocketNotifier::activate whenever the
140  * event specified by \c req is available.
141  */
142 class eSocketNotifier
143 {
144 public:
145         enum { Read=POLLIN, Write=POLLOUT, Priority=POLLPRI, Error=POLLERR, Hungup=POLLHUP };
146 private:
147         eMainloop &context;
148         int fd;
149         int state;
150         int requested;          // requested events (POLLIN, ...)
151 public:
152         /**
153          * \brief Constructs a eSocketNotifier.
154          * \param context The thread where to bind the socketnotifier to. The signal is emitted from that thread.
155          * \param fd The filedescriptor to monitor. Can be a device or a socket.
156          * \param req The events to watch to, normally either \c Read or \c Write. You can specify any events that \c poll supports.
157          * \param startnow Specifies if the socketnotifier should start immediately.
158          */
159         eSocketNotifier(eMainloop *context, int fd, int req, bool startnow=true);
160         ~eSocketNotifier();
161
162         PSignal1<void, int> activated;
163         void activate(int what) { /*emit*/ activated(what); }
164
165         void start();
166         void stop();
167         bool isRunning() { return state; }
168
169         int getFD() { return fd; }
170         int getRequested() { return requested; }
171         void setRequested(int req) { requested=req; }
172 };
173
174                                 // ... und Timer
175 /**
176  * \brief Gives a callback after a specified timeout.
177  *
178  * This class emits the signal \c eTimer::timeout after the specified timeout.
179  */
180 class eTimer
181 {
182         eMainloop &context;
183         timeval nextActivation;
184         long interval;
185         bool bSingleShot;
186         bool bActive;
187 public:
188         /**
189          * \brief Constructs a timer.
190          *
191          * The timer is not yet active, it has to be started with \c start.
192          * \param context The thread from which the signal should be emitted.
193          */
194         eTimer(eMainloop *context): context(*context), bActive(false) { }
195         ~eTimer()       { if (bActive) stop(); }
196
197         PSignal0<void> timeout;
198         void activate();
199
200         bool isActive() { return bActive; }
201         timeval &getNextActivation() { return nextActivation; }
202
203         void start(long msec, bool singleShot=false);
204         void stop();
205         void changeInterval(long msek);
206         bool operator<(const eTimer& t) const   {               return nextActivation < t.nextActivation;               }
207 };
208
209                         // werden in einer mainloop verarbeitet
210 class eMainloop
211 {
212         std::map<int, eSocketNotifier*> notifiers;
213         ePtrList<eTimer> TimerList;
214         bool app_exit_loop;
215         bool app_quit_now;
216         int loop_level;
217         void processOneEvent();
218         int retval;
219 public:
220         eMainloop():app_quit_now(0),loop_level(0),retval(0){    }
221         void addSocketNotifier(eSocketNotifier *sn);
222         void removeSocketNotifier(eSocketNotifier *sn);
223         void addTimer(eTimer* e)        {               TimerList.push_back(e);         TimerList.sort();       }
224         void removeTimer(eTimer* e)     {               TimerList.remove(e);    }
225
226         int looplevel() { return loop_level; }
227         
228         int exec();  // recursive enter the loop
229         void quit(int ret=0); // leave all pending loops (recursive leave())
230         void enter_loop();
231         void exit_loop();
232 };
233
234 /**
235  * \brief The application class.
236  *
237  * An application provides a mainloop, and runs in the primary thread.
238  * You can have other threads, too, but this is the primary one.
239  */
240 class eApplication: public eMainloop
241 {
242 public:
243         eApplication()
244         {
245                 if (!eApp)
246                         eApp = this;
247         }
248         ~eApplication()
249         {
250                 eApp = 0;
251         }
252 };
253 #endif