9ea9ccaf3f9bf2f3b29ef860898f580cc839e47a
[dana/dcompmgr.git] / screen.c
1 #include "screen.h"
2 #include "display.h"
3 #include "list.h"
4 #include "time.h"
5 #include "window.h"
6 #include "gettext.h"
7 #include <string.h>
8 #include <stdlib.h>
9 #include <stdio.h>
10 #include <xcb/composite.h>
11
12 #define ROOT_MASK      (XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | \
13                         XCB_EVENT_MASK_STRUCTURE_NOTIFY)
14
15 #define SELECTION_MASK (XCB_EVENT_MASK_STRUCTURE_NOTIFY | \
16                         XCB_EVENT_MASK_PROPERTY_CHANGE)
17
18 static gboolean screen_init(d_screen_t *sc);
19 static xcb_timestamp_t screen_timestamp(d_screen_t *sc);
20 static void screen_add_existing_windows(d_screen_t *sc);
21 static void screen_set_next_repaint(d_screen_t *sc);
22
23 static guint
24 xcb_window_hash(xcb_window_t *w) { return *w; }
25
26 static gboolean
27 xcb_window_equal(xcb_window_t *w1, xcb_window_t *w2) { return *w1 == *w2; }
28
29
30 d_screen_t*
31 screen_new(struct d_display *dpy, int num, xcb_screen_t *xcb)
32 {
33     d_screen_t *sc;
34
35     sc = malloc(sizeof(d_screen_t));
36     sc->super = *xcb;
37     sc->ref = 1;
38     sc->dpy = dpy;
39     sc->num = num;
40
41     gettimeofday(&sc->next_repaint, NULL);
42     sc->need_repaint = TRUE;
43
44     sc->winhash = g_hash_table_new((GHashFunc)xcb_window_hash,
45                                    (GEqualFunc)xcb_window_equal);
46     sc->stacking = list_new();
47     sc->plugin_data = g_hash_table_new_full((GHashFunc)g_str_hash,
48                                             (GEqualFunc)g_str_equal,
49                                             g_free, NULL);
50
51     return sc;
52 }
53
54 void
55 screen_ref(d_screen_t *sc)
56 {
57     ++sc->ref;
58 }
59
60 void
61 screen_unref(d_screen_t *sc)
62 {
63     if (sc && --sc->ref == 0) {
64         g_hash_table_unref(sc->winhash);
65         list_unref(sc->stacking);
66         g_hash_table_unref(sc->plugin_data);
67         free(sc);
68     }
69 }
70
71 gboolean
72 screen_register(d_screen_t *sc)
73 {
74     char *name;
75     xcb_window_t w;
76     xcb_intern_atom_cookie_t ack;
77     xcb_intern_atom_reply_t *arep;
78     xcb_get_selection_owner_cookie_t sck;
79     xcb_get_selection_owner_reply_t *srep;
80     uint32_t event_mask;
81     gboolean taken, ret;
82
83     w = xcb_generate_id(sc->dpy->conn);
84     event_mask = SELECTION_MASK;
85     xcb_create_window(sc->dpy->conn, XCB_COPY_FROM_PARENT, w, sc->super.root,
86                       0, 0, 1, 1, 0, XCB_WINDOW_CLASS_INPUT_ONLY,
87                       sc->super.root_visual, XCB_CW_EVENT_MASK, &event_mask);
88
89     name = g_strdup_printf("_NET_WM_CM_S%d", sc->num);
90     ack = xcb_intern_atom(sc->dpy->conn, FALSE, strlen(name), name);
91     arep = xcb_intern_atom_reply(sc->dpy->conn, ack, NULL);
92     g_free(name);
93
94     xcb_grab_server(sc->dpy->conn);
95
96     sck = xcb_get_selection_owner(sc->dpy->conn, arep->atom);
97     srep = xcb_get_selection_owner_reply(sc->dpy->conn, sck, NULL);
98     taken = !!srep->owner;
99     free(srep);
100     if (taken) {
101         printf(_("screen %d already has a composite manager, skipping\n"),
102                sc->num);
103         ret = FALSE;
104     }
105     else {
106         xcb_timestamp_t time;
107
108         sc->selwin = w;
109         sc->selatom = arep->atom;
110
111         time = screen_timestamp(sc);
112
113         xcb_set_selection_owner(sc->dpy->conn, w, arep->atom, time);
114         sck = xcb_get_selection_owner(sc->dpy->conn, arep->atom);
115         srep = xcb_get_selection_owner_reply(sc->dpy->conn, sck, NULL);
116         taken = srep->owner == w;
117         if (taken && screen_init(sc)) {
118             screen_add_existing_windows(sc);
119             ret = TRUE;
120         }
121         else {
122             xcb_destroy_window(sc->dpy->conn, w);
123             ret = FALSE;
124         }
125     }
126
127     xcb_ungrab_server(sc->dpy->conn);
128     xcb_flush(sc->dpy->conn);
129
130     return ret;
131 }
132
133 static gboolean
134 screen_init(d_screen_t *sc)
135 {
136     uint32_t mask;
137 #if DO_COMP
138     xcb_generic_error_t *err;
139     xcb_void_cookie_t redir_ck;
140     xcb_composite_get_overlay_window_cookie_t overlay_ck;
141     xcb_composite_get_overlay_window_reply_t *overlay_rep;
142
143     redir_ck =
144         xcb_composite_redirect_subwindows(sc->dpy->conn, sc->super.root,
145                                           XCB_COMPOSITE_REDIRECT_MANUAL);
146
147     overlay_ck = xcb_composite_get_overlay_window(sc->dpy->conn,
148                                                   sc->super.root);
149
150     /* check that the redirect worked */
151     err = xcb_request_check(sc->dpy->conn, redir_ck);
152     if (err) {
153         printf(_("unable to redirect rendering, another composite manager must be running"));
154         free(err);
155         return FALSE;
156     }
157
158     /* get the overlay window reply */
159     overlay_rep = xcb_composite_get_overlay_window_reply(sc->dpy->conn,
160                                                          overlay_ck,
161                                                          NULL);
162     if (!overlay_rep) {
163         printf(_("unable to get the composite overlay window\n"));
164         return FALSE;
165     }
166     sc->overlay = overlay_rep->overlay_win;
167     free(overlay_rep);
168 #endif
169
170     mask = SELECTION_MASK;
171     xcb_change_window_attributes(sc->dpy->conn, sc->selwin,
172                                  XCB_CW_EVENT_MASK, &mask);
173     mask = ROOT_MASK;
174     xcb_change_window_attributes(sc->dpy->conn, sc->super.root,
175                                  XCB_CW_EVENT_MASK, &mask);
176
177     return TRUE;
178 }
179
180 void
181 screen_add_window(d_screen_t *sc, xcb_window_t wid)
182 {
183     d_window_t *w;
184
185     /* XXX xgetwindowattributes - size and tings */
186
187     w = window_new(wid, sc);
188     g_hash_table_insert(sc->winhash, &w->id, w);
189
190     printf("screen added window 0x%x\n", w->id);
191 }
192
193 static void
194 screen_add_existing_windows(d_screen_t *sc)
195 {
196     xcb_query_tree_cookie_t ck;
197     xcb_query_tree_reply_t *rep;
198
199     ck = xcb_query_tree(sc->dpy->conn, sc->super.root);
200     rep = xcb_query_tree_reply(sc->dpy->conn, ck, NULL);
201     if (rep) {
202         xcb_window_iterator_t it;
203
204         printf("query\n");
205         it = xcb_query_tree_children_iterator(rep);
206         for (; it.rem; xcb_window_next(&it))
207             screen_add_window(sc, *it.data);
208
209         free(rep);
210     }
211 }
212
213 void
214 screen_remove_window(d_screen_t *sc, struct d_window *w)
215 {
216     printf("screen removed window 0x%x\n", w->id);
217
218     g_hash_table_remove(sc->winhash, &w->id);
219     sc->window_become_zombie(w);
220     window_unref(w);
221 }
222
223 d_window_t*
224 screen_find_window(d_screen_t *sc, xcb_window_t id)
225 {
226     return g_hash_table_lookup(sc->winhash, &id);
227 }
228
229 static xcb_timestamp_t
230 screen_timestamp(d_screen_t *sc)
231 {
232     xcb_void_cookie_t ck;
233     xcb_timestamp_t   time;
234
235     ck = xcb_change_property(sc->dpy->conn, XCB_PROP_MODE_REPLACE, sc->selwin,
236                              sc->selatom, sc->selatom, 32, 0, NULL);
237     xcb_flush(sc->dpy->conn);
238     while (1) {
239         xcb_generic_event_t *ev;
240
241         ev = xcb_wait_for_event(sc->dpy->conn);
242         if (!ev) {
243             printf(_("IO error\n"));
244             exit(0);
245         }
246
247         /* expect errors.. */
248         if (!ev->response_type) {
249             display_error(sc->dpy, (xcb_generic_error_t*)ev);
250             free(ev);
251             continue;
252         }
253
254         if (ev->response_type == XCB_PROPERTY_NOTIFY &&
255             ev->full_sequence == ck.sequence)
256         {
257             time = ((xcb_property_notify_event_t*)ev)->time;
258             free(ev);
259             break;
260         }
261     }
262     printf("created timestamp %lu\n", (unsigned long) time);
263     return time;
264 }
265
266 void
267 screen_stacking_add(d_screen_t *sc, struct d_window *w)
268 {
269     list_prepend(sc->stacking, w);
270 }
271
272 void
273 screen_stacking_remove(d_screen_t *sc, struct d_window *w)
274 {
275     list_remove(sc->stacking, w);
276 }
277
278 static void
279 screen_set_next_repaint(d_screen_t *sc)
280 {
281     gettimeofday(&sc->next_repaint, NULL);
282     /* add time for the refresh rate (60 hz) */
283     time_add(&sc->next_repaint, 1000000/60);
284     sc->need_repaint = FALSE;
285 }
286
287 void
288 screen_setup_default_functions(d_screen_t *sc)
289 {
290     sc->screen_paint = screen_set_next_repaint;
291     sc->window_show = window_show;
292     sc->window_hide = window_hide;
293     sc->window_become_zombie = window_become_zombie;
294
295 }
296
297 void
298 screen_add_plugin_data(d_screen_t *sc, const char *key, void *data)
299 {
300     char *skey = g_strdup(key);
301     g_hash_table_insert(sc->plugin_data, skey, data);
302 }
303
304 void*
305 screen_find_plugin_data(d_screen_t *sc, const char *key)
306 {
307     return g_hash_table_lookup(sc->plugin_data, key);
308 }
309
310 void
311 screen_remove_plugin_data(d_screen_t *sc, const char *key)
312 {
313     g_hash_table_remove(sc->plugin_data, key);
314 }
315
316 void screen_refresh(d_screen_t *sc)
317 {
318     sc->need_repaint = TRUE;
319 }