use select to tell when there are events to read
[dana/dcompmgr.git] / dcompmgr.c
1 #include "screen.h"
2 #include "window.h"
3 #include "display.h"
4 #include "gettext.h"
5
6 #include <glib.h>
7 #include <stdio.h>
8 #include <sys/select.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <xcb/xcb.h>
12
13 typedef struct {
14     int foo;
15 } d_options_t;
16
17 static void
18 read_options(int argc, char **argv, d_options_t *opts)
19 {
20     opts->foo = argc && argv;
21 }
22
23 static void
24 event(d_display_t *dpy)
25 {
26     xcb_generic_event_t *ev;
27
28     ev = xcb_poll_for_event(dpy->conn);
29     printf("event %d\n", ev->response_type);
30
31     if (!ev->response_type) {
32         display_error(dpy, (xcb_generic_error_t*)ev);
33         free(ev);
34         return;
35     }
36
37     switch (ev->response_type) {
38     case XCB_CREATE_NOTIFY:
39     {
40         xcb_create_notify_event_t *cev;
41         d_screen_t *sc;
42
43         cev = (xcb_create_notify_event_t*)ev;
44         sc = display_screen_from_root(dpy, cev->parent);
45         if (!sc) break;
46         screen_add_window(sc, cev->window);
47         break;
48     }
49     case XCB_DESTROY_NOTIFY:
50     {
51         xcb_destroy_notify_event_t *dev;
52         d_screen_t *sc;
53         d_window_t *w;
54
55         dev = (xcb_destroy_notify_event_t*)ev;
56         sc = display_screen_from_root(dpy, dev->event);
57         if (!sc) break;
58         w = screen_find_window(sc, dev->window);
59         w->hide(w);
60         screen_remove_window(sc, w);
61         break;
62     }
63     case XCB_REPARENT_NOTIFY:
64     {
65         xcb_reparent_notify_event_t *rev;
66         d_screen_t *sc;
67         d_window_t *w;
68
69         rev = (xcb_reparent_notify_event_t*)ev;
70         sc = display_screen_from_root(dpy, rev->event);
71         if (!sc) break;
72         w = screen_find_window(sc, rev->window);
73         if (rev->parent == sc->super.root)
74             screen_add_window(sc, rev->window);
75         else {
76             w->hide(w);
77             screen_remove_window(sc, w);
78         }
79         break;
80     }
81     case XCB_MAP_NOTIFY:
82     {
83         xcb_map_notify_event_t *mev;
84         d_screen_t *sc;
85         d_window_t *w;
86
87         mev = (xcb_map_notify_event_t*)ev;
88         sc = display_screen_from_root(dpy, mev->event);
89         if (!sc) break;
90         w = screen_find_window(sc, mev->window);
91         w->show(w);
92         break;
93     }
94     case XCB_UNMAP_NOTIFY:
95     {
96         xcb_unmap_notify_event_t *mev;
97         d_screen_t *sc;
98         d_window_t *w;
99
100         mev = (xcb_unmap_notify_event_t*)ev;
101         sc = display_screen_from_root(dpy, mev->event);
102         if (!sc) break;
103         w = screen_find_window(sc, mev->window);
104         w->hide(w);
105         break;
106     }
107     default:
108         break;
109     }
110     free(ev);
111 }
112
113 static void
114 run(d_display_t *dpy)
115 {
116     gboolean quit;
117     fd_set   fds;
118     int      max = -1;
119
120     FD_ZERO(&fds);
121     FD_SET(dpy->fd, &fds);
122     max = MAX(max, dpy->fd);
123
124     quit = FALSE;
125     while (!quit) {
126         int r;
127
128         r = select(max+1, &fds, NULL, NULL, NULL);
129         if (r < 0)
130             printf("select error\n");
131         else if (r == 0)
132             printf("select timeout\n");
133         else {
134             printf("select data\n");
135             /*if (FD_ISSET(dpy->fd, &fds))*/ {
136                 event(dpy);
137             }
138         }
139
140         if (xcb_connection_has_error(dpy->conn))
141             quit = TRUE;
142     }
143 }
144
145 int
146 main(int argc, char **argv)
147 {
148     d_display_t         *dpy;
149     d_options_t          opts;
150
151     read_options(argc, argv, &opts);
152
153     dpy = display_open(NULL);
154     if (!dpy) {
155         printf(_("Unable to connect to display\n"));
156         return 1;
157     }
158
159     if (!dpy->composite.present) {
160         printf(_("no composite extension present on the display\n"));
161         display_unref(dpy);
162         return 1;
163     }
164     if (!dpy->xfixes.present) {
165         printf(_("no xfixes extension present on the display\n"));
166         display_unref(dpy);
167         return 1;
168     }
169     if (!dpy->damage.present) {
170         printf(_("no damage extension present on the display\n"));
171         display_unref(dpy);
172         return 1;
173     }
174     if (!dpy->render.present) {
175         printf(_("no render extension present on the display\n"));
176         display_unref(dpy);
177         return 1;
178     }
179     if (dpy->composite.major_version <= 0 && dpy->composite.minor_version < 3)
180     {
181         printf(_("composite extension does not support the overlay window"));
182         display_unref(dpy);
183         return 1;
184     }
185
186     if (!display_claim_screens(dpy)) {
187         printf(_("found no screens to run on\n"));
188         display_unref(dpy);
189         return 0;
190     }
191
192     run(dpy);
193
194     display_unref(dpy);
195     return 0;
196 }