commit 0366670
Michael Forney
·
2014-01-21 04:09:54 +0000 UTC
parent 558f094
Use global compositor state
6 files changed,
+90,
-105
+77,
-65
1@@ -35,7 +35,6 @@ struct view
2 {
3 struct swc_view base;
4 struct wl_listener event_listener;
5- struct swc_compositor * compositor;
6 struct swc_surface * surface;
7 struct wld_buffer * wld;
8
9@@ -56,8 +55,33 @@ struct view
10 struct wl_list link;
11 };
12
13+static void handle_focus(struct swc_pointer * pointer);
14+static bool handle_motion(struct swc_pointer * pointer, uint32_t time);
15 static void perform_update(void * data);
16
17+static struct
18+{
19+ struct wl_list views;
20+ pixman_region32_t damage, opaque;
21+
22+ /* A mask of screens that have been repainted but are waiting on a page
23+ * flip. */
24+ uint32_t pending_flips;
25+
26+ /* A mask of screens that are scheduled to be repainted on the next
27+ * idle. */
28+ uint32_t scheduled_updates;
29+
30+ struct wl_global * global;
31+} compositor;
32+
33+const struct swc_compositor swc_compositor = {
34+ .pointer_handler = {
35+ .focus = &handle_focus,
36+ .motion = &handle_motion
37+ }
38+};
39+
40 static void buffer_destroy(void * data)
41 {
42 struct swc_buffer * buffer = data;
43@@ -131,9 +155,9 @@ static void handle_screen_view_event(struct wl_listener * listener, void * data)
44 if (!(screen = screen_get(&base->base)))
45 return;
46
47- swc.compositor->pending_flips &= ~swc_screen_mask(base);
48+ compositor.pending_flips &= ~swc_screen_mask(base);
49
50- wl_list_for_each(view, &swc.compositor->views, link)
51+ wl_list_for_each(view, &compositor.views, link)
52 {
53 if (view->base.screens & swc_screen_mask(base))
54 swc_view_frame(&view->base, event_data->frame.time);
55@@ -146,8 +170,8 @@ static void handle_screen_view_event(struct wl_listener * listener, void * data)
56
57 /* If we had scheduled updates that couldn't run because we were
58 * waiting on a page flip, run them now. */
59- if (swc.compositor->scheduled_updates)
60- perform_update(swc.compositor);
61+ if (compositor.scheduled_updates)
62+ perform_update(NULL);
63 break;
64 }
65 }
66@@ -353,12 +377,11 @@ static void renderer_flush_view(struct view * view)
67 */
68 static void damage_below_view(struct view * view)
69 {
70- struct swc_compositor * compositor = view->compositor;
71 pixman_region32_t damage_below;
72
73 pixman_region32_init_with_extents(&damage_below, &view->extents);
74 pixman_region32_subtract(&damage_below, &damage_below, &view->clip);
75- pixman_region32_union(&compositor->damage, &compositor->damage,
76+ pixman_region32_union(&compositor.damage, &compositor.damage,
77 &damage_below);
78 pixman_region32_fini(&damage_below);
79 }
80@@ -385,22 +408,20 @@ static void update_extents(struct view * view)
81 view->border.damaged = true;
82 }
83
84-static void schedule_updates(struct swc_compositor * compositor, uint32_t screens)
85+static void schedule_updates(uint32_t screens)
86 {
87- if (compositor->scheduled_updates == 0)
88+ if (compositor.scheduled_updates == 0)
89 wl_event_loop_add_idle(swc.event_loop, &perform_update, NULL);
90
91- compositor->scheduled_updates |= screens;
92+ compositor.scheduled_updates |= screens;
93 }
94
95-static bool update(struct swc_view * base)
96+static bool update(struct swc_view * view)
97 {
98- struct view * view = (void *) base;
99-
100- if (!view->base.visible)
101+ if (!view->visible)
102 return false;
103
104- schedule_updates(view->compositor, view->base.screens);
105+ schedule_updates(view->screens);
106
107 return true;
108 }
109@@ -488,8 +509,7 @@ static void handle_view_event(struct wl_listener * listener, void * data)
110 }
111 }
112
113-bool swc_compositor_add_surface(struct swc_compositor * compositor,
114- struct swc_surface * surface)
115+bool swc_compositor_add_surface(struct swc_surface * surface)
116 {
117 struct view * view;
118
119@@ -502,7 +522,6 @@ bool swc_compositor_add_surface(struct swc_compositor * compositor,
120 view->base.visible = false;
121 view->event_listener.notify = &handle_view_event;
122 wl_signal_add(&view->base.event_signal, &view->event_listener);
123- view->compositor = compositor;
124 view->surface = surface;
125 view->wld = NULL;
126 view->extents.x1 = 0;
127@@ -537,7 +556,7 @@ void swc_compositor_surface_show(struct swc_surface * surface)
128 damage_view(view);
129 swc_view_set_visibility(&view->base, true);
130 update(&view->base);
131- wl_list_insert(&view->compositor->views, &view->link);
132+ wl_list_insert(&compositor.views, &view->link);
133 }
134
135 void swc_compositor_surface_hide(struct swc_surface * surface)
136@@ -593,19 +612,19 @@ void swc_compositor_surface_set_border_color(struct swc_surface * surface,
137
138 /* }}} */
139
140-static void calculate_damage(struct swc_compositor * compositor)
141+static void calculate_damage()
142 {
143 struct view * view;
144 pixman_region32_t surface_opaque, * surface_damage;
145
146- pixman_region32_clear(&compositor->opaque);
147+ pixman_region32_clear(&compositor.opaque);
148 pixman_region32_init(&surface_opaque);
149
150 /* Go through views top-down to calculate clipping regions. */
151- wl_list_for_each(view, &compositor->views, link)
152+ wl_list_for_each(view, &compositor.views, link)
153 {
154 /* Clip the surface by the opaque region covering it. */
155- pixman_region32_copy(&view->clip, &compositor->opaque);
156+ pixman_region32_copy(&view->clip, &compositor.opaque);
157
158 /* Translate the opaque region to global coordinates. */
159 pixman_region32_copy(&surface_opaque, &view->surface->state.opaque);
160@@ -614,7 +633,7 @@ static void calculate_damage(struct swc_compositor * compositor)
161
162 /* Add the surface's opaque region to the accumulated opaque
163 * region. */
164- pixman_region32_union(&compositor->opaque, &compositor->opaque,
165+ pixman_region32_union(&compositor.opaque, &compositor.opaque,
166 &surface_opaque);
167
168 surface_damage = &view->surface->state.damage;
169@@ -628,7 +647,7 @@ static void calculate_damage(struct swc_compositor * compositor)
170 (surface_damage, view->base.geometry.x, view->base.geometry.y);
171
172 /* Add the surface damage to the compositor damage. */
173- pixman_region32_union(&compositor->damage, &compositor->damage,
174+ pixman_region32_union(&compositor.damage, &compositor.damage,
175 surface_damage);
176 pixman_region32_clear(surface_damage);
177 }
178@@ -645,7 +664,7 @@ static void calculate_damage(struct swc_compositor * compositor)
179 pixman_region32_subtract(&border_region, &border_region,
180 &view_region);
181
182- pixman_region32_union(&compositor->damage, &compositor->damage,
183+ pixman_region32_union(&compositor.damage, &compositor.damage,
184 &border_region);
185
186 pixman_region32_fini(&border_region);
187@@ -658,21 +677,20 @@ static void calculate_damage(struct swc_compositor * compositor)
188 pixman_region32_fini(&surface_opaque);
189 }
190
191-static void update_screen(struct swc_compositor * compositor,
192- struct swc_screen_internal * base)
193+static void update_screen(struct swc_screen_internal * base)
194 {
195 struct screen * screen;
196 const struct swc_rectangle * geometry = &base->base.geometry;
197 pixman_region32_t damage;
198
199- if (!(compositor->scheduled_updates & swc_screen_mask(base)))
200+ if (!(compositor.scheduled_updates & swc_screen_mask(base)))
201 return;
202
203 if (!(screen = screen_get(&base->base)))
204 return;
205
206 pixman_region32_init(&damage);
207- pixman_region32_intersect_rect(&damage, &compositor->damage,
208+ pixman_region32_intersect_rect(&damage, &compositor.damage,
209 geometry->x, geometry->y,
210 geometry->width, geometry->height);
211 pixman_region32_translate(&damage, -geometry->x, -geometry->y);
212@@ -680,7 +698,7 @@ static void update_screen(struct swc_compositor * compositor,
213 &screen->next_buffer->damage, &damage);
214
215 /* Don't repaint the screen if it is waiting for a page flip. */
216- if (compositor->pending_flips & swc_screen_mask(base))
217+ if (compositor.pending_flips & swc_screen_mask(base))
218 return;
219
220 struct render_target target;
221@@ -690,48 +708,45 @@ static void update_screen(struct swc_compositor * compositor,
222 &screen->next_buffer->damage);
223 pixman_region32_translate(total_damage, geometry->x, geometry->y);
224 pixman_region32_init(&base_damage);
225- pixman_region32_subtract(&base_damage, total_damage, &compositor->opaque);
226+ pixman_region32_subtract(&base_damage, total_damage, &compositor.opaque);
227
228 target.surface = screen->surface;
229 target.mask = swc_screen_mask(base);
230 target.geometry = geometry;
231
232- renderer_repaint(&target, total_damage, &base_damage, &compositor->views);
233+ renderer_repaint(&target, total_damage, &base_damage, &compositor.views);
234 pixman_region32_fini(&base_damage);
235 screen_swap_buffers(screen);
236 }
237
238 static void perform_update(void * data)
239 {
240- struct swc_compositor * compositor = data;
241 struct swc_screen_internal * screen;
242- uint32_t updates = compositor->scheduled_updates
243- & ~compositor->pending_flips;
244+ uint32_t updates = compositor.scheduled_updates
245+ & ~compositor.pending_flips;
246
247 if (!updates)
248 return;
249
250 DEBUG("Performing update\n");
251
252- calculate_damage(compositor);
253+ calculate_damage();
254
255 wl_list_for_each(screen, &swc.screens, link)
256- update_screen(compositor, screen);
257+ update_screen(screen);
258
259 /* XXX: Should assert that all damage was covered by some output */
260- pixman_region32_clear(&compositor->damage);
261- compositor->pending_flips |= updates;
262- compositor->scheduled_updates &= ~updates;
263+ pixman_region32_clear(&compositor.damage);
264+ compositor.pending_flips |= updates;
265+ compositor.scheduled_updates &= ~updates;
266 }
267
268-static void handle_focus(struct swc_pointer * pointer)
269+void handle_focus(struct swc_pointer * pointer)
270 {
271- /* XXX: Temporary hack */
272- struct swc_compositor * compositor = swc.compositor;
273 struct view * view;
274 int32_t x, y;
275
276- wl_list_for_each(view, &compositor->views, link)
277+ wl_list_for_each(view, &compositor.views, link)
278 {
279 x = wl_fixed_to_int(pointer->x);
280 y = wl_fixed_to_int(pointer->y);
281@@ -749,16 +764,15 @@ static void handle_focus(struct swc_pointer * pointer)
282 swc_pointer_set_focus(pointer, NULL);
283 }
284
285-static bool handle_motion(struct swc_pointer * pointer, uint32_t time)
286+bool handle_motion(struct swc_pointer * pointer, uint32_t time)
287 {
288 return false;
289 }
290
291 static void handle_terminate(uint32_t time, uint32_t value, void * data)
292 {
293- struct wl_display * display = data;
294 printf("handling terminate\n");
295- wl_display_terminate(display);
296+ wl_display_terminate(swc.display);
297 }
298
299 static void handle_switch_vt(uint32_t time, uint32_t value, void * data)
300@@ -814,33 +828,28 @@ static void bind_compositor(struct wl_client * client, void * data,
301 compositor, NULL);
302 }
303
304-bool swc_compositor_initialize(struct swc_compositor * compositor,
305- struct wl_display * display,
306- struct wl_event_loop * event_loop)
307+bool swc_compositor_initialize()
308 {
309 struct swc_screen_internal * screen;
310 uint32_t keysym;
311
312- wl_global_create(swc.display, &wl_compositor_interface, 3, compositor,
313- &bind_compositor);
314+ compositor.global = wl_global_create
315+ (swc.display, &wl_compositor_interface, 3, NULL, &bind_compositor);
316
317- compositor->display = display;
318- compositor->scheduled_updates = 0;
319- compositor->pending_flips = 0;
320- compositor->pointer_handler = (struct swc_pointer_handler) {
321- .focus = &handle_focus,
322- .motion = &handle_motion
323- };
324+ if (!compositor.global)
325+ return false;
326
327- pixman_region32_init(&compositor->damage);
328- pixman_region32_init(&compositor->opaque);
329- wl_list_init(&compositor->views);
330+ compositor.scheduled_updates = 0;
331+ compositor.pending_flips = 0;
332+ pixman_region32_init(&compositor.damage);
333+ pixman_region32_init(&compositor.opaque);
334+ wl_list_init(&compositor.views);
335
336 wl_list_for_each(screen, &swc.screens, link)
337 screen_new(screen);
338
339 swc_add_key_binding(SWC_MOD_CTRL | SWC_MOD_ALT, XKB_KEY_BackSpace,
340- &handle_terminate, display);
341+ &handle_terminate, NULL);
342
343 for (keysym = XKB_KEY_XF86Switch_VT_1;
344 keysym <= XKB_KEY_XF86Switch_VT_12;
345@@ -854,7 +863,10 @@ bool swc_compositor_initialize(struct swc_compositor * compositor,
346 return true;
347 }
348
349-void swc_compositor_finish(struct swc_compositor * compositor)
350+void swc_compositor_finalize()
351 {
352+ pixman_region32_fini(&compositor.damage);
353+ pixman_region32_fini(&compositor.opaque);
354+ wl_global_destroy(compositor.global);
355 }
356
+4,
-31
1@@ -3,43 +3,16 @@
2
3 #include "pointer.h"
4
5-#include <wayland-server.h>
6-
7-struct swc_screen_internal;
8-
9 struct swc_compositor
10 {
11- struct wl_display * display;
12- struct wl_list views;
13-
14- /* Internal state related to repainting the screen. */
15- struct
16- {
17- pixman_region32_t damage;
18- pixman_region32_t opaque;
19-
20- /* A mask of outputs that have been repainted but are waiting on a page
21- * flip. */
22- uint32_t pending_flips;
23-
24- /* A mask of outputs that are scheduled to be repainted on the next
25- * idle. */
26- uint32_t scheduled_updates;
27- };
28-
29 struct swc_pointer_handler pointer_handler;
30 };
31
32-bool swc_compositor_initialize(struct swc_compositor * compositor,
33- struct wl_display * display,
34- struct wl_event_loop * event_loop);
35-
36-void swc_compositor_finish(struct swc_compositor * compositor);
37+bool swc_compositor_initialize();
38+void swc_compositor_finalize();
39
40-bool swc_compositor_add_surface(struct swc_compositor * compositor,
41- struct swc_surface * surface);
42-bool swc_compositor_remove_surface(struct swc_compositor * compositor,
43- struct swc_surface * surface);
44+bool swc_compositor_add_surface(struct swc_surface * surface);
45+bool swc_compositor_remove_surface(struct swc_surface * surface);
46
47 void swc_compositor_surface_show(struct swc_surface * surface);
48 void swc_compositor_surface_hide(struct swc_surface * surface);
+1,
-1
1@@ -38,7 +38,7 @@ struct swc
2 const struct swc_seat_global * const seat;
3 const struct swc_bindings_global * const bindings;
4 struct wl_list screens;
5- struct swc_compositor * compositor;
6+ const struct swc_compositor * const compositor;
7 struct swc_shm * const shm;
8 struct swc_drm * const drm;
9 };
+1,
-1
1@@ -40,7 +40,7 @@ struct swc_pointer
2 } hotspot;
3 } cursor;
4
5- struct swc_pointer_handler * handler;
6+ const struct swc_pointer_handler * handler;
7
8 wl_fixed_t x, y;
9 pixman_region32_t region;
+6,
-6
1@@ -45,15 +45,15 @@
2 extern struct swc_launch swc_launch;
3 extern const struct swc_seat_global seat_global;
4 extern const struct swc_bindings_global bindings_global;
5+extern const struct swc_compositor swc_compositor;
6 extern struct swc_drm drm_global;
7 extern struct swc_shm shm_global;
8-static struct swc_compositor compositor;
9
10 struct swc swc = {
11 .launch = &swc_launch,
12 .seat = &seat_global,
13 .bindings = &bindings_global,
14- .compositor = &compositor,
15+ .compositor = &swc_compositor,
16 .drm = &drm_global,
17 .shm = &shm_global
18 };
19@@ -66,7 +66,7 @@ static void setup_compositor()
20
21 wl_list_insert(&swc.seat->keyboard->handlers,
22 &swc.bindings->keyboard_handler->link);
23- swc.seat->pointer->handler = &compositor.pointer_handler;
24+ swc.seat->pointer->handler = &swc.compositor->pointer_handler;
25 wl_signal_add(&swc.seat->pointer->focus.event_signal,
26 swc_window_enter_listener);
27
28@@ -131,7 +131,7 @@ bool swc_initialize(struct wl_display * display,
29 goto error5;
30 }
31
32- if (!swc_compositor_initialize(&compositor, display, swc.event_loop))
33+ if (!swc_compositor_initialize())
34 {
35 ERROR("Could not initialize compositor\n");
36 goto error6;
37@@ -174,7 +174,7 @@ bool swc_initialize(struct wl_display * display,
38 error8:
39 swc_data_device_manager_finalize();
40 error7:
41- swc_compositor_finish(&compositor);
42+ swc_compositor_finalize();
43 error6:
44 swc_screens_finalize();
45 error5:
46@@ -200,7 +200,7 @@ void swc_finalize()
47 swc_shell_finalize();
48 swc_seat_finalize();
49 swc_data_device_manager_finalize();
50- swc_compositor_finish(&compositor);
51+ swc_compositor_finalize();
52 swc_screens_finalize();
53 swc_bindings_finalize();
54 swc_shm_finalize();
+1,
-1
1@@ -125,7 +125,7 @@ bool swc_window_initialize(struct swc_window * window,
2 INTERNAL(window)->impl = impl;
3
4 surface->window = window;
5- swc_compositor_add_surface(swc.compositor, surface);
6+ swc_compositor_add_surface(surface);
7
8 swc.manager->new_window(window);
9