Use ngettext for %d desktop(s).
[mikachu/openbox.git] / openbox / mainloop.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    mainloop.c for the Openbox window manager
4    Copyright (c) 2006        Mikael Magnusson
5    Copyright (c) 2003-2007   Dana Jansens
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    See the COPYING file for a copy of the GNU General Public License.
18 */
19
20 #include "mainloop.h"
21 #include "event.h"
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <sys/select.h>
26 #include <signal.h>
27
28 typedef struct _ObMainLoopTimer             ObMainLoopTimer;
29 typedef struct _ObMainLoopSignal            ObMainLoopSignal;
30 typedef struct _ObMainLoopSignalHandlerType ObMainLoopSignalHandlerType;
31 typedef struct _ObMainLoopXHandlerType      ObMainLoopXHandlerType;
32 typedef struct _ObMainLoopFdHandlerType     ObMainLoopFdHandlerType;
33
34 /* this should be more than the number of possible signals on any
35    architecture... */
36 #define NUM_SIGNALS 99
37
38 /* all created ObMainLoops. Used by the signal handler to pass along signals */
39 static GSList *all_loops;
40
41 /* signals are global to all loops */
42 static struct {
43     guint installed; /* a ref count */
44     struct sigaction oldact;
45 } all_signals[NUM_SIGNALS];
46
47 /* a set of all possible signals */
48 static sigset_t all_signals_set;
49
50 /* signals which cause a core dump, these can't be used for callbacks */
51 static gint core_signals[] =
52 {
53     SIGABRT,
54     SIGSEGV,
55     SIGFPE,
56     SIGILL,
57     SIGQUIT,
58     SIGTRAP,
59     SIGSYS,
60     SIGBUS,
61     SIGXCPU,
62     SIGXFSZ
63 };
64 #define NUM_CORE_SIGNALS (sizeof(core_signals) / sizeof(core_signals[0]))
65
66 static void sighandler(gint sig);
67 static void timer_dispatch(ObMainLoop *loop, GTimeVal **wait);
68 static void fd_handler_destroy(gpointer data);
69
70 struct _ObMainLoop
71 {
72     Display *display;
73
74     gboolean run;     /* do keep running */
75     gboolean running; /* is still running */
76
77     GSList *x_handlers;
78
79     gint fd_x; /* The X fd is a special case! */
80     gint fd_max;
81     GHashTable *fd_handlers;
82     fd_set fd_set;
83
84     GSList *timers;
85     GTimeVal now;
86     GTimeVal ret_wait;
87
88     gboolean signal_fired;
89     guint signals_fired[NUM_SIGNALS];
90     GSList *signal_handlers[NUM_SIGNALS];
91 };
92
93 struct _ObMainLoopTimer
94 {
95     gulong delay;
96     GSourceFunc func;
97     gpointer data;
98     GEqualFunc equal;
99     GDestroyNotify destroy;
100
101     /* The timer needs to be freed */
102     gboolean del_me;
103     /* The time the last fire should've been at */
104     GTimeVal last;
105     /* When this timer will next trigger */
106     GTimeVal timeout;
107
108     /* Only allow a timer's function to fire once per run through the list,
109        so that it doesn't get locked in there forever */
110     gboolean fired;
111 };
112
113 struct _ObMainLoopSignalHandlerType
114 {
115     ObMainLoop *loop;
116     gint signal;
117     gpointer data;
118     ObMainLoopSignalHandler func;
119     GDestroyNotify destroy;
120 };
121
122 struct _ObMainLoopXHandlerType
123 {
124     ObMainLoop *loop;
125     gpointer data;
126     ObMainLoopXHandler func;
127     GDestroyNotify destroy;
128 };
129
130 struct _ObMainLoopFdHandlerType
131 {
132     ObMainLoop *loop;
133     gint fd;
134     gpointer data;
135     ObMainLoopFdHandler func;
136     GDestroyNotify destroy;
137 };
138
139 ObMainLoop *ob_main_loop_new(Display *display)
140 {
141     ObMainLoop *loop;
142
143     loop = g_new0(ObMainLoop, 1);
144     loop->display = display;
145     loop->fd_x = ConnectionNumber(display);
146     FD_ZERO(&loop->fd_set);
147     FD_SET(loop->fd_x, &loop->fd_set);
148     loop->fd_max = loop->fd_x;
149
150     loop->fd_handlers = g_hash_table_new_full(g_int_hash, g_int_equal,
151                                               NULL, fd_handler_destroy);
152
153     g_get_current_time(&loop->now);
154
155     /* only do this if we're the first loop created */
156     if (!all_loops) {
157         guint i;
158         struct sigaction action;
159         sigset_t sigset;
160
161         /* initialize the all_signals_set */
162         sigfillset(&all_signals_set);
163
164         sigemptyset(&sigset);
165         action.sa_handler = sighandler;
166         action.sa_mask = sigset;
167         action.sa_flags = SA_NOCLDSTOP;
168
169         /* grab all the signals that cause core dumps */
170         for (i = 0; i < NUM_CORE_SIGNALS; ++i) {
171             /* SIGABRT is curiously not grabbed here!! that's because when we
172                get one of the core_signals, we use abort() to dump the core.
173                And having the abort() only go back to our signal handler again
174                is less than optimal */
175             if (core_signals[i] != SIGABRT) {
176                 sigaction(core_signals[i], &action,
177                           &all_signals[core_signals[i]].oldact);
178                 all_signals[core_signals[i]].installed++;
179             }
180         }
181     }
182
183     all_loops = g_slist_prepend(all_loops, loop);
184
185     return loop;
186 }
187
188 void ob_main_loop_destroy(ObMainLoop *loop)
189 {
190     guint i;
191     GSList *it, *next;
192
193     if (loop) {
194         g_assert(loop->running == FALSE);
195
196         for (it = loop->x_handlers; it; it = next) {
197             ObMainLoopXHandlerType *h = it->data;
198             next = g_slist_next(it);
199             ob_main_loop_x_remove(loop, h->func);
200         }
201
202         g_hash_table_destroy(loop->fd_handlers);
203
204         for (it = loop->timers; it; it = g_slist_next(it)) {
205             ObMainLoopTimer *t = it->data;
206             if (t->destroy) t->destroy(t->data);
207             g_free(t);
208         }
209         g_slist_free(loop->timers);
210         loop->timers = NULL;
211
212         for (i = 0; i < NUM_SIGNALS; ++i)
213             for (it = loop->signal_handlers[i]; it; it = next) {
214                 ObMainLoopSignalHandlerType *h = it->data;
215                 next = g_slist_next(it);
216                 ob_main_loop_signal_remove(loop, h->func);
217             }
218
219         all_loops = g_slist_remove(all_loops, loop);
220
221         /* only do this if we're the last loop destroyed */
222         if (!all_loops) {
223             /* grab all the signals that cause core dumps */
224             for (i = 0; i < NUM_CORE_SIGNALS; ++i) {
225                 if (all_signals[core_signals[i]].installed) {
226                     sigaction(core_signals[i],
227                               &all_signals[core_signals[i]].oldact, NULL);
228                     all_signals[core_signals[i]].installed--;
229                 }
230             }
231         }
232
233         g_free(loop);
234     }
235 }
236
237 static void fd_handle_foreach(gpointer key,
238                               gpointer value,
239                               gpointer data)
240 {
241     ObMainLoopFdHandlerType *h = value;
242     fd_set *set = data;
243
244     if (FD_ISSET(h->fd, set))
245         h->func(h->fd, h->data);
246 }
247
248 void ob_main_loop_run(ObMainLoop *loop)
249 {
250     XEvent e;
251     struct timeval *wait;
252     fd_set selset;
253     GSList *it;
254
255     loop->run = TRUE;
256     loop->running = TRUE;
257
258     while (loop->run) {
259         if (loop->signal_fired) {
260             guint i;
261             sigset_t oldset;
262
263             /* block signals so that we can do this without the data changing
264                on us */
265             sigprocmask(SIG_SETMASK, &all_signals_set, &oldset);
266
267             for (i = 0; i < NUM_SIGNALS; ++i) {
268                 while (loop->signals_fired[i]) {
269                     for (it = loop->signal_handlers[i];
270                             it; it = g_slist_next(it)) {
271                         ObMainLoopSignalHandlerType *h = it->data;
272                         h->func(i, h->data);
273                     }
274                     loop->signals_fired[i]--;
275                 }
276             }
277             loop->signal_fired = FALSE;
278
279             sigprocmask(SIG_SETMASK, &oldset, NULL);
280         } else if (XPending(loop->display)) {
281             do {
282                 XNextEvent(loop->display, &e);
283
284                 for (it = loop->x_handlers; it; it = g_slist_next(it)) {
285                     ObMainLoopXHandlerType *h = it->data;
286                     h->func(&e, h->data);
287                 }
288             } while (XPending(loop->display) && loop->run);
289         } else {
290             /* this only runs if there were no x events received */
291
292             timer_dispatch(loop, (GTimeVal**)&wait);
293
294             selset = loop->fd_set;
295             /* there is a small race condition here. if a signal occurs
296                between this if() and the select() then we will not process
297                the signal until 'wait' expires. possible solutions include
298                using GStaticMutex, and having the signal handler set 'wait'
299                to 0 */
300             if (!loop->signal_fired)
301                 select(loop->fd_max + 1, &selset, NULL, NULL, wait);
302
303             /* handle the X events with highest prioirity */
304             if (FD_ISSET(loop->fd_x, &selset))
305                 continue;
306
307             g_hash_table_foreach(loop->fd_handlers,
308                                  fd_handle_foreach, &selset);
309         }
310     }
311
312     loop->running = FALSE;
313 }
314
315 void ob_main_loop_exit(ObMainLoop *loop)
316 {
317     loop->run = FALSE;
318 }
319
320 /*** XEVENT WATCHERS ***/
321
322 void ob_main_loop_x_add(ObMainLoop *loop,
323                         ObMainLoopXHandler handler,
324                         gpointer data,
325                         GDestroyNotify notify)
326 {
327     ObMainLoopXHandlerType *h;
328
329     h = g_new(ObMainLoopXHandlerType, 1);
330     h->loop = loop;
331     h->func = handler;
332     h->data = data;
333     h->destroy = notify;
334     loop->x_handlers = g_slist_prepend(loop->x_handlers, h);
335 }
336
337 void ob_main_loop_x_remove(ObMainLoop *loop,
338                            ObMainLoopXHandler handler)
339 {
340     GSList *it, *next;
341
342     for (it = loop->x_handlers; it; it = next) {
343         ObMainLoopXHandlerType *h = it->data;
344         next = g_slist_next(it);
345         if (h->func == handler) {
346             loop->x_handlers = g_slist_delete_link(loop->x_handlers, it);
347             if (h->destroy) h->destroy(h->data);
348             g_free(h);
349         }
350     }
351 }
352
353 /*** SIGNAL WATCHERS ***/
354
355 static void sighandler(gint sig)
356 {
357     GSList *it;
358     guint i;
359
360     g_return_if_fail(sig < NUM_SIGNALS);
361
362     for (i = 0; i < NUM_CORE_SIGNALS; ++i)
363         if (sig == core_signals[i]) {
364             /* XXX special case for signals that default to core dump.
365                but throw some helpful output here... */
366
367             fprintf(stderr, "How are you gentlemen? All your base are"
368                     " belong to us. (Openbox received signal %d)\n", sig);
369
370             /* die with a core dump */
371             abort();
372         }
373
374     for (it = all_loops; it; it = g_slist_next(it)) {
375         ObMainLoop *loop = it->data;
376         loop->signal_fired = TRUE;
377         loop->signals_fired[sig]++;
378     }
379 }
380
381 void ob_main_loop_signal_add(ObMainLoop *loop,
382                              gint signal,
383                              ObMainLoopSignalHandler handler,
384                              gpointer data,
385                              GDestroyNotify notify)
386 {
387     ObMainLoopSignalHandlerType *h;
388
389     g_return_if_fail(signal < NUM_SIGNALS);
390
391     h = g_new(ObMainLoopSignalHandlerType, 1);
392     h->loop = loop;
393     h->signal = signal;
394     h->func = handler;
395     h->data = data;
396     h->destroy = notify;
397     loop->signal_handlers[h->signal] =
398         g_slist_prepend(loop->signal_handlers[h->signal], h);
399
400     if (!all_signals[signal].installed) {
401         struct sigaction action;
402         sigset_t sigset;
403
404         sigemptyset(&sigset);
405         action.sa_handler = sighandler;
406         action.sa_mask = sigset;
407         action.sa_flags = SA_NOCLDSTOP;
408
409         sigaction(signal, &action, &all_signals[signal].oldact);
410     }
411
412     all_signals[signal].installed++;
413 }
414
415 void ob_main_loop_signal_remove(ObMainLoop *loop,
416                                 ObMainLoopSignalHandler handler)
417 {
418     guint i;
419     GSList *it, *next;
420
421     for (i = 0; i < NUM_SIGNALS; ++i) {
422         for (it = loop->signal_handlers[i]; it; it = next) {
423             ObMainLoopSignalHandlerType *h = it->data;
424
425             next = g_slist_next(it);
426
427             if (h->func == handler) {
428                 g_assert(all_signals[h->signal].installed > 0);
429
430                 all_signals[h->signal].installed--;
431                 if (!all_signals[h->signal].installed) {
432                     sigaction(h->signal, &all_signals[h->signal].oldact, NULL);
433                 }
434
435                 loop->signal_handlers[i] =
436                     g_slist_delete_link(loop->signal_handlers[i], it);
437                 if (h->destroy) h->destroy(h->data);
438
439                 g_free(h);
440             }
441         }
442     }
443
444 }
445
446 /*** FILE DESCRIPTOR WATCHERS ***/
447
448 static void max_fd_func(gpointer key, gpointer value, gpointer data)
449 {
450     ObMainLoop *loop = data;
451
452     /* key is the fd */
453     loop->fd_max = MAX(loop->fd_max, *(gint*)key);
454 }
455
456 static void calc_max_fd(ObMainLoop *loop)
457 {
458     loop->fd_max = loop->fd_x;
459
460     g_hash_table_foreach(loop->fd_handlers, max_fd_func, loop);
461 }
462
463 void ob_main_loop_fd_add(ObMainLoop *loop,
464                          gint fd,
465                          ObMainLoopFdHandler handler,
466                          gpointer data,
467                          GDestroyNotify notify)
468 {
469     ObMainLoopFdHandlerType *h;
470
471     h = g_new(ObMainLoopFdHandlerType, 1);
472     h->loop = loop;
473     h->fd = fd;
474     h->func = handler;
475     h->data = data;
476     h->destroy = notify;
477
478     g_hash_table_replace(loop->fd_handlers, &h->fd, h);
479     FD_SET(h->fd, &loop->fd_set);
480     calc_max_fd(loop);
481 }
482
483 static void fd_handler_destroy(gpointer data)
484 {
485     ObMainLoopFdHandlerType *h = data;
486
487     FD_CLR(h->fd, &h->loop->fd_set);
488
489     if (h->destroy)
490         h->destroy(h->data);
491 }
492
493 void ob_main_loop_fd_remove(ObMainLoop *loop,
494                             gint fd)
495 {
496     g_hash_table_remove(loop->fd_handlers, &fd);
497 }
498
499 /*** TIMEOUTS ***/
500
501 #define NEAREST_TIMEOUT(loop) \
502     (((ObMainLoopTimer*)(loop)->timers->data)->timeout)
503
504 static glong timecompare(GTimeVal *a, GTimeVal *b)
505 {
506     glong r;
507     if ((r = a->tv_sec - b->tv_sec)) return r;
508     return a->tv_usec - b->tv_usec;
509 }
510
511 static void insert_timer(ObMainLoop *loop, ObMainLoopTimer *ins)
512 {
513     GSList *it;
514     for (it = loop->timers; it; it = g_slist_next(it)) {
515         ObMainLoopTimer *t = it->data;
516         if (timecompare(&ins->timeout, &t->timeout) <= 0) {
517             loop->timers = g_slist_insert_before(loop->timers, it, ins);
518             break;
519         }
520     }
521     if (it == NULL) /* didnt fit anywhere in the list */
522         loop->timers = g_slist_append(loop->timers, ins);
523 }
524
525 void ob_main_loop_timeout_add(ObMainLoop *loop,
526                               gulong microseconds,
527                               GSourceFunc handler,
528                               gpointer data,
529                               GEqualFunc cmp,
530                               GDestroyNotify notify)
531 {
532     ObMainLoopTimer *t = g_new(ObMainLoopTimer, 1);
533
534     g_assert(microseconds > 0); /* if it's 0 it'll cause an infinite loop */
535
536     t->delay = microseconds;
537     t->func = handler;
538     t->data = data;
539     t->equal = cmp;
540     t->destroy = notify;
541     t->del_me = FALSE;
542     g_get_current_time(&loop->now);
543     t->last = t->timeout = loop->now;
544     g_time_val_add(&t->timeout, t->delay);
545
546     insert_timer(loop, t);
547 }
548
549 void ob_main_loop_timeout_remove(ObMainLoop *loop,
550                                  GSourceFunc handler)
551 {
552     GSList *it;
553
554     for (it = loop->timers; it; it = g_slist_next(it)) {
555         ObMainLoopTimer *t = it->data;
556         if (t->func == handler)
557             t->del_me = TRUE;
558     }
559 }
560
561 void ob_main_loop_timeout_remove_data(ObMainLoop *loop, GSourceFunc handler,
562                                       gpointer data, gboolean cancel_dest)
563 {
564     GSList *it;
565
566     for (it = loop->timers; it; it = g_slist_next(it)) {
567         ObMainLoopTimer *t = it->data;
568         if (t->func == handler && t->equal(t->data, data)) {
569             t->del_me = TRUE;
570             if (cancel_dest)
571                 t->destroy = NULL;
572         }
573     }
574 }
575
576 /* find the time to wait for the nearest timeout */
577 static gboolean nearest_timeout_wait(ObMainLoop *loop, GTimeVal *tm)
578 {
579   if (loop->timers == NULL)
580     return FALSE;
581
582   tm->tv_sec = NEAREST_TIMEOUT(loop).tv_sec - loop->now.tv_sec;
583   tm->tv_usec = NEAREST_TIMEOUT(loop).tv_usec - loop->now.tv_usec;
584
585   while (tm->tv_usec < 0) {
586     tm->tv_usec += G_USEC_PER_SEC;
587     tm->tv_sec--;
588   }
589   tm->tv_sec += tm->tv_usec / G_USEC_PER_SEC;
590   tm->tv_usec %= G_USEC_PER_SEC;
591   if (tm->tv_sec < 0)
592     tm->tv_sec = 0;
593
594   return TRUE;
595 }
596
597 static void timer_dispatch(ObMainLoop *loop, GTimeVal **wait)
598 {
599     GSList *it, *next;
600
601     gboolean fired = FALSE;
602
603     g_get_current_time(&loop->now);
604
605     for (it = loop->timers; it; it = next) {
606         ObMainLoopTimer *curr;
607
608         next = g_slist_next(it);
609
610         curr = it->data;
611
612         /* since timer_stop doesn't actually free the timer, we have to do our
613            real freeing in here.
614         */
615         if (curr->del_me) {
616             /* delete the top */
617             loop->timers = g_slist_delete_link(loop->timers, it);
618             if (curr->destroy)
619                 curr->destroy(curr->data);
620             g_free(curr);
621             continue;
622         }
623
624         /* the queue is sorted, so if this timer shouldn't fire, none are
625            ready */
626         if (timecompare(&NEAREST_TIMEOUT(loop), &loop->now) > 0)
627             break;
628
629         /* we set the last fired time to delay msec after the previous firing,
630            then re-insert.  timers maintain their order and may trigger more
631            than once if they've waited more than one delay's worth of time.
632         */
633         loop->timers = g_slist_delete_link(loop->timers, it);
634         g_time_val_add(&curr->last, curr->delay);
635         if (curr->func(curr->data)) {
636             g_time_val_add(&curr->timeout, curr->delay);
637             insert_timer(loop, curr);
638         } else {
639             if (curr->destroy)
640                 curr->destroy(curr->data);
641             g_free(curr);
642         }
643
644         /* the timer queue has been shuffled, start from the beginning
645            (which is the next one to fire) */
646         next = loop->timers;
647
648         fired = TRUE;
649     }
650
651     if (fired) {
652         /* if at least one timer fires, then don't wait on X events, as there
653            may already be some in the queue from the timer callbacks.
654         */
655         loop->ret_wait.tv_sec = loop->ret_wait.tv_usec = 0;
656         *wait = &loop->ret_wait;
657     } else if (nearest_timeout_wait(loop, &loop->ret_wait))
658         *wait = &loop->ret_wait;
659     else
660         *wait = NULL;
661 }