use the list for holding all the managed screens in the display. limit the number...
[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     return ret;
130 }
131
132 static gboolean
133 screen_init(d_screen_t *sc)
134 {
135     uint32_t mask;
136 #if DO_COMP
137     xcb_generic_error_t *err;
138     xcb_void_cookie_t redir_ck;
139     xcb_composite_get_overlay_window_cookie_t overlay_ck;
140     xcb_composite_get_overlay_window_reply_t *overlay_rep;
141
142     redir_ck =
143         xcb_composite_redirect_subwindows(sc->dpy->conn, sc->super.root,
144                                           XCB_COMPOSITE_REDIRECT_MANUAL);
145
146     overlay_ck = xcb_composite_get_overlay_window(sc->dpy->conn,
147                                                   sc->super.root);
148
149     /* check that the redirect worked */
150     err = xcb_request_check(sc->dpy->conn, redir_ck);
151     if (err) {
152         printf(_("unable to redirect rendering, another composite manager must be running"));
153         free(err);
154         return FALSE;
155     }
156
157     /* get the overlay window reply */
158     overlay_rep = xcb_composite_get_overlay_window_reply(sc->dpy->conn,
159                                                          overlay_ck,
160                                                          NULL);
161     if (!overlay_rep) {
162         printf(_("unable to get the composite overlay window\n"));
163         return FALSE;
164     }
165     sc->overlay = overlay_rep->overlay_win;
166     free(overlay_rep);
167 #endif
168
169     mask = SELECTION_MASK;
170     xcb_change_window_attributes(sc->dpy->conn, sc->selwin,
171                                  XCB_CW_EVENT_MASK, &mask);
172     mask = ROOT_MASK;
173     xcb_change_window_attributes(sc->dpy->conn, sc->super.root,
174                                  XCB_CW_EVENT_MASK, &mask);
175
176     return TRUE;
177 }
178
179 void
180 screen_add_window(d_screen_t *sc, xcb_window_t wid)
181 {
182     d_window_t *w;
183
184     /* XXX xgetwindowattributes - size and tings */
185
186     w = window_new(wid, sc);
187     g_hash_table_insert(sc->winhash, &w->id, w);
188
189     printf("screen added window 0x%x\n", w->id);
190 }
191
192 static void
193 screen_add_existing_windows(d_screen_t *sc)
194 {
195     xcb_query_tree_cookie_t ck;
196     xcb_query_tree_reply_t *rep;
197
198     ck = xcb_query_tree(sc->dpy->conn, sc->super.root);
199     rep = xcb_query_tree_reply(sc->dpy->conn, ck, NULL);
200     if (rep) {
201         xcb_window_iterator_t it;
202
203         printf("query\n");
204         it = xcb_query_tree_children_iterator(rep);
205         for (; it.rem; xcb_window_next(&it))
206             screen_add_window(sc, *it.data);
207
208         free(rep);
209     }
210 }
211
212 void
213 screen_remove_window(d_screen_t *sc, struct d_window *w)
214 {
215     printf("screen removed window 0x%x\n", w->id);
216
217     g_hash_table_remove(sc->winhash, &w->id);
218     sc->window_become_zombie(w);
219     window_unref(w);
220 }
221
222 d_window_t*
223 screen_find_window(d_screen_t *sc, xcb_window_t id)
224 {
225     return g_hash_table_lookup(sc->winhash, &id);
226 }
227
228 static xcb_timestamp_t
229 screen_timestamp(d_screen_t *sc)
230 {
231     xcb_void_cookie_t ck;
232     xcb_timestamp_t   time;
233
234     ck = xcb_change_property(sc->dpy->conn, XCB_PROP_MODE_REPLACE, sc->selwin,
235                              sc->selatom, sc->selatom, 32, 0, NULL);
236     xcb_flush(sc->dpy->conn);
237     while (1) {
238         xcb_generic_event_t *ev;
239
240         ev = xcb_wait_for_event(sc->dpy->conn);
241         if (!ev) {
242             printf(_("IO error\n"));
243             exit(0);
244         }
245
246         /* expect errors.. */
247         if (!ev->response_type) {
248             display_error(sc->dpy, (xcb_generic_error_t*)ev);
249             free(ev);
250             continue;
251         }
252
253         if (ev->response_type == XCB_PROPERTY_NOTIFY &&
254             ev->full_sequence == ck.sequence)
255         {
256             time = ((xcb_property_notify_event_t*)ev)->time;
257             free(ev);
258             break;
259         }
260     }
261     printf("created timestamp %lu\n", (unsigned long) time);
262     return time;
263 }
264
265 void
266 screen_stacking_add(d_screen_t *sc, struct d_window *w)
267 {
268     list_prepend(sc->stacking, w);
269 }
270
271 void
272 screen_stacking_remove(d_screen_t *sc, struct d_window *w)
273 {
274     list_remove(sc->stacking, w);
275 }
276
277 static void
278 screen_set_next_repaint(d_screen_t *sc)
279 {
280     gettimeofday(&sc->next_repaint, NULL);
281     /* add time for the refresh rate (60 hz) */
282     time_add(&sc->next_repaint, 1000000/60);
283     sc->need_repaint = FALSE;
284 }
285
286 void
287 screen_setup_default_functions(d_screen_t *sc)
288 {
289     sc->screen_paint = screen_set_next_repaint;
290     sc->window_show = window_show;
291     sc->window_hide = window_hide;
292     sc->window_become_zombie = window_become_zombie;
293
294 }
295
296 void
297 screen_add_plugin_data(d_screen_t *sc, const char *key, void *data)
298 {
299     char *skey = g_strdup(key);
300     g_hash_table_insert(sc->plugin_data, skey, data);
301 }
302
303 void*
304 screen_find_plugin_data(d_screen_t *sc, const char *key)
305 {
306     return g_hash_table_lookup(sc->plugin_data, key);
307 }
308
309 void
310 screen_remove_plugin_data(d_screen_t *sc, const char *key)
311 {
312     g_hash_table_remove(sc->plugin_data, key);
313 }
314
315 void screen_refresh(d_screen_t *sc)
316 {
317     sc->need_repaint = TRUE;
318 }