blob: 0c62fb02966f53b48f9b85a703df47abf06b3ab4 [file] [log] [blame]
Kristian Høgsbergffd710e2008-12-02 15:15:01 -05001/*
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04002 * Copyright © 2010-2011 Intel Corporation
3 * Copyright © 2008-2011 Kristian Høgsberg
Pekka Paalanend581a8f2012-01-27 16:25:16 +02004 * Copyright © 2012 Collabora, Ltd.
Kristian Høgsbergffd710e2008-12-02 15:15:01 -05005 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04006 * Permission to use, copy, modify, distribute, and sell this software and
7 * its documentation for any purpose is hereby granted without fee, provided
8 * that the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of the copyright holders not be used in
11 * advertising or publicity pertaining to distribution of the software
12 * without specific, written prior permission. The copyright holders make
13 * no representations about the suitability of this software for any
14 * purpose. It is provided "as is" without express or implied warranty.
Kristian Høgsbergffd710e2008-12-02 15:15:01 -050015 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -040016 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
17 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
19 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
20 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
21 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
22 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Kristian Høgsbergffd710e2008-12-02 15:15:01 -050023 */
24
Kristian Høgsberg06bc2642010-12-01 09:50:16 -050025#define _GNU_SOURCE
26
Kristian Høgsberga9410222011-01-14 17:22:35 -050027#include "config.h"
28
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040029#include <stdio.h>
30#include <string.h>
31#include <stdlib.h>
32#include <stdint.h>
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +010033#include <limits.h>
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -050034#include <stdarg.h>
Benjamin Franzke6f5fc692011-06-21 19:34:19 +020035#include <assert.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040036#include <sys/ioctl.h>
Kristian Høgsberg27da5382011-06-21 17:32:25 -040037#include <sys/wait.h>
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020038#include <sys/types.h>
39#include <sys/socket.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040040#include <fcntl.h>
41#include <unistd.h>
Kristian Høgsberg54879822008-11-23 17:07:32 -050042#include <math.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040043#include <linux/input.h>
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -040044#include <dlfcn.h>
Kristian Høgsbergd34912c2011-05-02 10:36:04 -040045#include <getopt.h>
Kristian Høgsberg85449032011-05-02 12:11:07 -040046#include <signal.h>
Kristian Høgsberg0690da62012-01-16 11:53:54 -050047#include <setjmp.h>
48#include <execinfo.h>
Kristian Høgsberg890bc052008-12-30 14:31:33 -050049
Pekka Paalanen50719bc2011-11-22 14:18:50 +020050#include <wayland-server.h>
Kristian Høgsberg82863022010-06-04 21:52:02 -040051#include "compositor.h"
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050052
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -050053static const char *option_socket_name = NULL;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -050054
Kristian Høgsberg27da5382011-06-21 17:32:25 -040055static struct wl_list child_process_list;
Kristian Høgsberg0690da62012-01-16 11:53:54 -050056static jmp_buf segv_jmp_buf;
Kristian Høgsberg27da5382011-06-21 17:32:25 -040057
58static int
59sigchld_handler(int signal_number, void *data)
60{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050061 struct weston_process *p;
Kristian Høgsberg27da5382011-06-21 17:32:25 -040062 int status;
63 pid_t pid;
64
65 pid = wait(&status);
66 wl_list_for_each(p, &child_process_list, link) {
67 if (p->pid == pid)
68 break;
69 }
70
71 if (&p->link == &child_process_list) {
72 fprintf(stderr, "unknown child process exited\n");
73 return 1;
74 }
75
76 wl_list_remove(&p->link);
77 p->cleanup(p, status);
78
79 return 1;
80}
81
82WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050083weston_watch_process(struct weston_process *process)
Kristian Høgsberg27da5382011-06-21 17:32:25 -040084{
85 wl_list_insert(&child_process_list, &process->link);
86}
87
Benjamin Franzke06286262011-05-06 19:12:33 +020088static void
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020089child_client_exec(int sockfd, const char *path)
90{
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -050091 int clientfd;
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020092 char s[32];
Pekka Paalanenc47ddfd2011-12-08 10:44:56 +020093 sigset_t allsigs;
94
95 /* do not give our signal mask to the new process */
96 sigfillset(&allsigs);
97 sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020098
Kristian Høgsbergeb764842012-01-31 22:17:25 -050099 /* Launch clients as the user. */
100 seteuid(getuid());
101
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500102 /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
103 * non-CLOEXEC fd to pass through exec. */
104 clientfd = dup(sockfd);
105 if (clientfd == -1) {
106 fprintf(stderr, "compositor: dup failed: %m\n");
107 return;
108 }
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200109
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500110 snprintf(s, sizeof s, "%d", clientfd);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200111 setenv("WAYLAND_SOCKET", s, 1);
112
113 if (execl(path, path, NULL) < 0)
114 fprintf(stderr, "compositor: executing '%s' failed: %m\n",
115 path);
116}
117
118WL_EXPORT struct wl_client *
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500119weston_client_launch(struct weston_compositor *compositor,
120 struct weston_process *proc,
121 const char *path,
122 weston_process_cleanup_func_t cleanup)
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200123{
124 int sv[2];
125 pid_t pid;
126 struct wl_client *client;
127
128 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500129 fprintf(stderr, "weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200130 "socketpair failed while launching '%s': %m\n",
131 path);
132 return NULL;
133 }
134
135 pid = fork();
136 if (pid == -1) {
137 close(sv[0]);
138 close(sv[1]);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500139 fprintf(stderr, "weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200140 "fork failed while launching '%s': %m\n", path);
141 return NULL;
142 }
143
144 if (pid == 0) {
145 child_client_exec(sv[1], path);
146 exit(-1);
147 }
148
149 close(sv[1]);
150
151 client = wl_client_create(compositor->wl_display, sv[0]);
152 if (!client) {
153 close(sv[0]);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500154 fprintf(stderr, "weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200155 "wl_client_create failed while launching '%s'.\n",
156 path);
157 return NULL;
158 }
159
160 proc->pid = pid;
161 proc->cleanup = cleanup;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500162 weston_watch_process(proc);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200163
164 return client;
165}
166
167static void
Benjamin Franzke06286262011-05-06 19:12:33 +0200168surface_handle_buffer_destroy(struct wl_listener *listener,
169 struct wl_resource *resource, uint32_t time)
170{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500171 struct weston_surface *es =
172 container_of(listener, struct weston_surface,
173 buffer_destroy_listener);
Benjamin Franzke06286262011-05-06 19:12:33 +0200174
Kristian Høgsberg24596942011-10-24 17:51:02 -0400175 es->buffer = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200176}
177
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500178WL_EXPORT struct weston_surface *
Kristian Høgsberg18c93002012-01-27 11:58:31 -0500179weston_surface_create(struct weston_compositor *compositor)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500180{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500181 struct weston_surface *surface;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400182
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200183 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400184 if (surface == NULL)
185 return NULL;
186
Kristian Høgsbergf6b14712011-01-06 15:32:14 -0500187 wl_list_init(&surface->link);
Benjamin Franzkebab41fb2011-03-07 18:04:59 +0100188 wl_list_init(&surface->buffer_link);
Kristian Høgsbergc551bd22010-12-06 16:43:16 -0500189
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400190 surface->surface.resource.client = NULL;
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400191
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500192 surface->compositor = compositor;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500193 surface->visual = WESTON_NONE_VISUAL;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200194 surface->image = EGL_NO_IMAGE_KHR;
Kristian Høgsberg541e5552011-12-14 09:24:11 -0500195 surface->alpha = 255;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400196
Kristian Høgsbergcbd06f92011-10-12 16:29:31 -0400197 surface->fullscreen_output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200198 surface->buffer = NULL;
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400199 surface->output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200200
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400201 pixman_region32_init(&surface->damage);
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400202 pixman_region32_init(&surface->opaque);
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500203 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400204
Benjamin Franzke06286262011-05-06 19:12:33 +0200205 surface->buffer_destroy_listener.func = surface_handle_buffer_destroy;
Benjamin Franzke06286262011-05-06 19:12:33 +0200206
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200207 wl_list_init(&surface->geometry.transformation_list);
Pekka Paalanencd403622012-01-25 13:37:39 +0200208 wl_list_insert(&surface->geometry.transformation_list,
209 &surface->transform.position.link);
210 weston_matrix_init(&surface->transform.position.matrix);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200211 pixman_region32_init(&surface->transform.boundingbox);
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200212 surface->geometry.dirty = 1;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500213
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400214 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500215}
216
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500217static void
218weston_surface_set_color(struct weston_surface *surface,
219 GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
220{
221 if (alpha == 1)
222 surface->visual = WESTON_RGB_VISUAL;
223 else
224 surface->visual = WESTON_ARGB_VISUAL;
225
226 surface->color[0] = red;
227 surface->color[1] = green;
228 surface->color[2] = blue;
229 surface->color[3] = alpha;
230 surface->shader = &surface->compositor->solid_shader;
231}
232
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200233static void
Pekka Paalanenece8a012012-02-08 15:23:15 +0200234surface_to_global_float(struct weston_surface *surface,
235 int32_t sx, int32_t sy, GLfloat *x, GLfloat *y)
236{
237 if (surface->transform.enabled) {
238 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
239
240 weston_matrix_transform(&surface->transform.matrix, &v);
241
242 if (fabsf(v.f[3]) < 1e-6) {
243 fprintf(stderr, "warning: numerical instability in "
244 "weston_surface_to_global(), divisor = %g\n",
245 v.f[3]);
246 *x = 0;
247 *y = 0;
248 return;
249 }
250
251 *x = v.f[0] / v.f[3];
252 *y = v.f[1] / v.f[3];
253 } else {
254 *x = sx + surface->geometry.x;
255 *y = sy + surface->geometry.y;
256 }
257}
258
259static void
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200260weston_surface_damage_below_noupdate(struct weston_surface *surface)
261{
262 struct weston_surface *below;
263
264 if (surface->output == NULL)
265 return;
266
267 if (surface->link.next == &surface->compositor->surface_list)
268 return;
269
270 below = container_of(surface->link.next, struct weston_surface, link);
271 pixman_region32_union(&below->damage, &below->damage,
272 &surface->transform.boundingbox);
273}
274
275static void
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200276surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy,
277 int32_t width, int32_t height,
278 pixman_region32_t *bbox)
279{
Pekka Paalanen219b9822012-02-08 15:38:37 +0200280 GLfloat min_x = HUGE_VALF, min_y = HUGE_VALF;
281 GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200282 int32_t s[4][2] = {
283 { sx, sy },
284 { sx, sy + height },
285 { sx + width, sy },
286 { sx + width, sy + height }
287 };
Pekka Paalanen219b9822012-02-08 15:38:37 +0200288 GLfloat int_x, int_y;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200289 int i;
290
291 for (i = 0; i < 4; ++i) {
Pekka Paalanen219b9822012-02-08 15:38:37 +0200292 GLfloat x, y;
293 surface_to_global_float(surface, s[i][0], s[i][1], &x, &y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200294 if (x < min_x)
295 min_x = x;
296 if (x > max_x)
297 max_x = x;
298 if (y < min_y)
299 min_y = y;
300 if (y > max_y)
301 max_y = y;
302 }
303
Pekka Paalanen219b9822012-02-08 15:38:37 +0200304 int_x = floorf(min_x);
305 int_y = floorf(min_y);
306 pixman_region32_init_rect(bbox, int_x, int_y,
307 ceilf(max_x) - int_x, ceilf(max_y) - int_y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200308}
309
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200310static void
311weston_surface_update_transform_disable(struct weston_surface *surface)
312{
313 surface->transform.enabled = 0;
314
315 pixman_region32_init_rect(&surface->transform.boundingbox,
316 surface->geometry.x,
317 surface->geometry.y,
318 surface->geometry.width,
319 surface->geometry.height);
320}
321
322static int
323weston_surface_update_transform_enable(struct weston_surface *surface)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200324{
325 struct weston_matrix *matrix = &surface->transform.matrix;
326 struct weston_matrix *inverse = &surface->transform.inverse;
327 struct weston_transform *tform;
328
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200329 surface->transform.enabled = 1;
330
331 /* Otherwise identity matrix, but with x and y translation. */
332 surface->transform.position.matrix.d[12] = surface->geometry.x;
333 surface->transform.position.matrix.d[13] = surface->geometry.y;
334
335 weston_matrix_init(matrix);
336 wl_list_for_each(tform, &surface->geometry.transformation_list, link)
337 weston_matrix_multiply(matrix, &tform->matrix);
338
339 if (weston_matrix_invert(inverse, matrix) < 0) {
340 /* Oops, bad total transformation, not invertible */
341 fprintf(stderr, "error: weston_surface %p"
342 " transformation not invertible.\n", surface);
343 return -1;
344 }
345
346 surface_compute_bbox(surface, 0, 0, surface->geometry.width,
347 surface->geometry.height,
348 &surface->transform.boundingbox);
349 return 0;
350}
351
352WL_EXPORT void
353weston_surface_update_transform(struct weston_surface *surface)
354{
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200355 if (!surface->geometry.dirty)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200356 return;
357
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200358 surface->geometry.dirty = 0;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200359
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200360 pixman_region32_fini(&surface->transform.boundingbox);
361
Pekka Paalanencd403622012-01-25 13:37:39 +0200362 /* transform.position is always in transformation_list */
363 if (surface->geometry.transformation_list.next ==
364 &surface->transform.position.link &&
365 surface->geometry.transformation_list.prev ==
366 &surface->transform.position.link) {
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200367 weston_surface_update_transform_disable(surface);
368 } else {
369 if (weston_surface_update_transform_enable(surface) < 0)
370 weston_surface_update_transform_disable(surface);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200371 }
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200372}
373
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200374WL_EXPORT void
375weston_surface_to_global(struct weston_surface *surface,
376 int32_t sx, int32_t sy, int32_t *x, int32_t *y)
377{
378 GLfloat xf, yf;
379
380 weston_surface_update_transform(surface);
381
382 surface_to_global_float(surface, sx, sy, &xf, &yf);
383 *x = floorf(xf);
384 *y = floorf(yf);
385}
386
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200387static void
388surface_from_global_float(struct weston_surface *surface,
389 int32_t x, int32_t y, GLfloat *sx, GLfloat *sy)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200390{
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200391 if (surface->transform.enabled) {
392 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
393
394 weston_matrix_transform(&surface->transform.inverse, &v);
395
396 if (fabsf(v.f[3]) < 1e-6) {
397 fprintf(stderr, "warning: numerical instability in "
398 "weston_surface_from_global(), divisor = %g\n",
399 v.f[3]);
400 *sx = 0;
401 *sy = 0;
402 return;
403 }
404
Pekka Paalanencd403622012-01-25 13:37:39 +0200405 *sx = v.f[0] / v.f[3];
406 *sy = v.f[1] / v.f[3];
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200407 } else {
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200408 *sx = x - surface->geometry.x;
409 *sy = y - surface->geometry.y;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200410 }
411}
412
413WL_EXPORT void
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200414weston_surface_from_global(struct weston_surface *surface,
415 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
416{
417 GLfloat sxf, syf;
418
419 weston_surface_update_transform(surface);
420
421 surface_from_global_float(surface, x, y, &sxf, &syf);
422 *sx = floorf(sxf);
423 *sy = floorf(syf);
424}
425
426WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500427weston_surface_damage_rectangle(struct weston_surface *surface,
Pekka Paalanen2267d452012-01-26 13:12:45 +0200428 int32_t sx, int32_t sy,
429 int32_t width, int32_t height)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500430{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200431 weston_surface_update_transform(surface);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500432
Pekka Paalanen2267d452012-01-26 13:12:45 +0200433 if (surface->transform.enabled) {
434 pixman_region32_t box;
435 surface_compute_bbox(surface, sx, sy, width, height, &box);
436 pixman_region32_union(&surface->damage, &surface->damage,
437 &box);
438 pixman_region32_fini(&box);
439 } else {
440 int32_t x, y;
441 weston_surface_to_global(surface, sx, sy, &x, &y);
442 pixman_region32_union_rect(&surface->damage, &surface->damage,
443 x, y, width, height);
444 }
445
446 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500447}
448
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400449WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500450weston_surface_damage(struct weston_surface *surface)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500451{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200452 weston_surface_update_transform(surface);
453
454 pixman_region32_union(&surface->damage, &surface->damage,
455 &surface->transform.boundingbox);
456
457 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500458}
459
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400460WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500461weston_surface_damage_below(struct weston_surface *surface)
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400462{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200463 weston_surface_update_transform(surface);
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200464 weston_surface_damage_below_noupdate(surface);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500465 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400466}
467
Kristian Høgsberg90b53812012-01-18 21:41:37 -0500468static void
469weston_surface_flush_damage(struct weston_surface *surface)
470{
471 struct weston_surface *below;
472
473 if (surface->output &&
474 surface->link.next != &surface->compositor->surface_list) {
475 below = container_of(surface->link.next,
476 struct weston_surface, link);
477
478 pixman_region32_union(&below->damage,
479 &below->damage, &surface->damage);
480 }
481}
482
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400483WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500484weston_surface_configure(struct weston_surface *surface,
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200485 GLfloat x, GLfloat y, int width, int height)
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400486{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500487 weston_surface_damage_below(surface);
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400488
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200489 surface->geometry.x = x;
490 surface->geometry.y = y;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200491 surface->geometry.width = width;
492 surface->geometry.height = height;
Pekka Paalanencd403622012-01-25 13:37:39 +0200493 surface->geometry.dirty = 1;
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400494
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500495 weston_surface_assign_output(surface);
496 weston_surface_damage(surface);
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400497
498 pixman_region32_fini(&surface->opaque);
Pekka Paalanen9f9aa1b2012-02-06 16:26:57 +0200499 if (surface->visual == WESTON_RGB_VISUAL &&
500 surface->transform.enabled == 0)
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400501 pixman_region32_init_rect(&surface->opaque,
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200502 surface->geometry.x,
503 surface->geometry.y,
Pekka Paalanen60921e52012-01-25 15:55:43 +0200504 surface->geometry.width,
505 surface->geometry.height);
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400506 else
507 pixman_region32_init(&surface->opaque);
508}
509
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400510WL_EXPORT uint32_t
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500511weston_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500512{
513 struct timeval tv;
514
515 gettimeofday(&tv, NULL);
516
517 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
518}
519
Pekka Paalanenf0fc70d2011-11-15 13:34:54 +0200520WL_EXPORT void
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500521weston_device_repick(struct wl_input_device *device, uint32_t time)
522{
523 struct weston_input_device *wd = (struct weston_input_device *) device;
524 const struct wl_grab_interface *interface;
525 struct weston_surface *surface, *focus;
526
527 surface = weston_compositor_pick_surface(wd->compositor,
528 device->x, device->y,
529 &device->current_x,
530 &device->current_y);
531
532 if (&surface->surface != device->current) {
533 interface = device->grab->interface;
534 interface->focus(device->grab, time, &surface->surface,
535 device->current_x, device->current_y);
536 device->current = &surface->surface;
537 }
538
539 focus = (struct weston_surface *) device->grab->focus;
540 if (focus)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200541 weston_surface_from_global(focus, device->x, device->y,
542 &device->grab->x, &device->grab->y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500543}
544
545WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500546weston_compositor_repick(struct weston_compositor *compositor)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400547{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500548 struct weston_input_device *device;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400549 uint32_t time;
550
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500551 if (!compositor->focus)
552 return;
553
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500554 time = weston_compositor_get_time();
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500555 wl_list_for_each(device, &compositor->input_device_list, link)
556 weston_device_repick(&device->input_device, time);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400557}
558
559static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400560destroy_surface(struct wl_resource *resource)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500561{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500562 struct weston_surface *surface =
563 container_of(resource,
564 struct weston_surface, surface.resource);
565 struct weston_compositor *compositor = surface->compositor;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400566
Kristian Høgsbergd1e86252012-01-30 09:10:14 -0500567 if (surface->output) {
568 weston_surface_damage_below(surface);
569 weston_surface_flush_damage(surface);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500570
Kristian Høgsbergd1e86252012-01-30 09:10:14 -0500571 wl_list_remove(&surface->link);
572 weston_compositor_repick(compositor);
573 }
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400574
Kristian Høgsberg46e64ee2012-01-26 09:28:42 -0500575 glDeleteTextures(1, &surface->texture);
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200576
Benjamin Franzke06286262011-05-06 19:12:33 +0200577 if (surface->buffer)
578 wl_list_remove(&surface->buffer_destroy_listener.link);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400579
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200580 if (surface->image != EGL_NO_IMAGE_KHR)
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400581 compositor->destroy_image(compositor->display,
582 surface->image);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200583
Benjamin Franzkebab41fb2011-03-07 18:04:59 +0100584 wl_list_remove(&surface->buffer_link);
585
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200586 pixman_region32_fini(&surface->transform.boundingbox);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200587 pixman_region32_fini(&surface->damage);
588 pixman_region32_fini(&surface->opaque);
589
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400590 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500591}
592
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100593static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500594weston_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface)
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100595{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500596 struct weston_surface *es = (struct weston_surface *) surface;
597 struct weston_compositor *ec = es->compositor;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100598 struct wl_list *surfaces_attached_to;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100599
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500600 if (!es->texture) {
601 glGenTextures(1, &es->texture);
602 glBindTexture(GL_TEXTURE_2D, es->texture);
603 glTexParameteri(GL_TEXTURE_2D,
604 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
605 glTexParameteri(GL_TEXTURE_2D,
606 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
607 es->shader = &ec->texture_shader;
608 } else {
609 glBindTexture(GL_TEXTURE_2D, es->texture);
610 }
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100611
612 if (wl_buffer_is_shm(buffer)) {
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200613 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100614 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200615 es->pitch, buffer->height, 0,
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100616 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
617 wl_shm_buffer_get_data(buffer));
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400618
619 switch (wl_shm_buffer_get_format(buffer)) {
Kristian Høgsberg8e81df42012-01-11 14:24:46 -0500620 case WL_SHM_FORMAT_ARGB8888:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500621 es->visual = WESTON_ARGB_VISUAL;
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400622 break;
Kristian Høgsberg8e81df42012-01-11 14:24:46 -0500623 case WL_SHM_FORMAT_XRGB8888:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500624 es->visual = WESTON_RGB_VISUAL;
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400625 break;
626 }
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100627
628 surfaces_attached_to = buffer->user_data;
629
Kristian Høgsbergfac11d22011-05-02 13:35:17 -0400630 wl_list_remove(&es->buffer_link);
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100631 wl_list_insert(surfaces_attached_to, &es->buffer_link);
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100632 } else {
Benjamin Franzkefb4b5a22011-06-21 10:44:37 +0200633 if (es->image != EGL_NO_IMAGE_KHR)
634 ec->destroy_image(ec->display, es->image);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400635 es->image = ec->create_image(ec->display, NULL,
636 EGL_WAYLAND_BUFFER_WL,
637 buffer, NULL);
638
639 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400640
Kristian Høgsberg8e81df42012-01-11 14:24:46 -0500641 es->visual = WESTON_ARGB_VISUAL;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200642 es->pitch = es->geometry.width;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100643 }
644}
645
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400646static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500647texture_region(struct weston_surface *es, pixman_region32_t *region)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500648{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500649 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500650 GLfloat *v, inv_width, inv_height;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200651 GLfloat sx, sy;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500652 pixman_box32_t *rectangles;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400653 unsigned int *p;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500654 int i, n;
655
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400656 rectangles = pixman_region32_rectangles(region, &n);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500657 v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
658 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200659 inv_width = 1.0 / es->pitch;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200660 inv_height = 1.0 / es->geometry.height;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400661
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500662 for (i = 0; i < n; i++, v += 16, p += 6) {
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200663 surface_from_global_float(es, rectangles[i].x1,
664 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500665 v[ 0] = rectangles[i].x1;
666 v[ 1] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200667 v[ 2] = sx * inv_width;
668 v[ 3] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500669
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200670 surface_from_global_float(es, rectangles[i].x1,
671 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500672 v[ 4] = rectangles[i].x1;
673 v[ 5] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200674 v[ 6] = sx * inv_width;
675 v[ 7] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500676
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200677 surface_from_global_float(es, rectangles[i].x2,
678 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500679 v[ 8] = rectangles[i].x2;
680 v[ 9] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200681 v[10] = sx * inv_width;
682 v[11] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500683
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200684 surface_from_global_float(es, rectangles[i].x2,
685 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500686 v[12] = rectangles[i].x2;
687 v[13] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200688 v[14] = sx * inv_width;
689 v[15] = sy * inv_height;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500690
691 p[0] = i * 4 + 0;
692 p[1] = i * 4 + 1;
693 p[2] = i * 4 + 2;
694 p[3] = i * 4 + 2;
695 p[4] = i * 4 + 1;
696 p[5] = i * 4 + 3;
697 }
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500698
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400699 return n;
700}
701
Kristian Høgsberg68c479a2012-01-25 23:32:28 -0500702WL_EXPORT void
Kristian Høgsberga0d6dc42012-01-25 22:02:00 -0500703weston_surface_draw(struct weston_surface *es, struct weston_output *output)
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400704{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500705 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400706 GLfloat *v;
707 pixman_region32_t repaint;
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400708 GLint filter;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400709 int n;
710
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200711 weston_surface_update_transform(es);
712
713 pixman_region32_init(&repaint);
714 pixman_region32_intersect(&repaint, &es->transform.boundingbox,
715 &output->region);
Kristian Høgsberga0d6dc42012-01-25 22:02:00 -0500716 pixman_region32_intersect(&repaint, &repaint, &es->damage);
717
Pekka Paalanenc7b45f62012-02-06 12:16:07 +0200718 /* Clear damage, assume outputs do not overlap. */
719 pixman_region32_subtract(&es->damage, &es->damage, &output->region);
720
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400721 if (!pixman_region32_not_empty(&repaint))
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200722 goto out;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400723
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400724 switch (es->visual) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500725 case WESTON_ARGB_VISUAL:
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400726 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
727 glEnable(GL_BLEND);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400728 break;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500729 case WESTON_RGB_VISUAL:
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400730 glDisable(GL_BLEND);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400731 break;
732 default:
733 fprintf(stderr, "bogus visual\n");
734 break;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400735 }
736
Kristian Høgsberg07632622012-01-25 23:02:06 -0500737 if (ec->current_shader != es->shader) {
738 glUseProgram(es->shader->program);
Kristian Høgsberg07632622012-01-25 23:02:06 -0500739 ec->current_shader = es->shader;
740 }
741
Kristian Høgsberg0452abc2012-01-31 15:38:36 -0500742 glUniformMatrix4fv(es->shader->proj_uniform,
743 1, GL_FALSE, output->matrix.d);
Pekka Paalanenf55f5442012-02-02 16:49:05 +0200744 glUniform1i(es->shader->tex_uniform, 0);
745 glUniform4fv(es->shader->color_uniform, 1, es->color);
746 glUniform1f(es->shader->alpha_uniform, es->alpha / 255.0);
747 glUniform1f(es->shader->texwidth_uniform,
748 (GLfloat)es->geometry.width / es->pitch);
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200749
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200750 if (es->transform.enabled)
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400751 filter = GL_LINEAR;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200752 else
Pekka Paalanenc61eca62012-01-06 14:10:06 +0200753 filter = GL_NEAREST;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200754
755 n = texture_region(es, &repaint);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400756
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500757 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400758 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
759 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
760
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500761 v = ec->vertices.data;
762 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
763 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400764 glEnableVertexAttribArray(0);
765 glEnableVertexAttribArray(1);
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200766
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500767 glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
768
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200769 glDisableVertexAttribArray(1);
770 glDisableVertexAttribArray(0);
771
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500772 ec->vertices.size = 0;
773 ec->indices.size = 0;
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200774
775out:
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500776 pixman_region32_fini(&repaint);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500777}
778
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500779WL_EXPORT struct wl_list *
780weston_compositor_top(struct weston_compositor *compositor)
781{
782 struct weston_input_device *input_device;
783 struct wl_list *list;
784
785 input_device = (struct weston_input_device *) compositor->input_device;
786
787 /* Insert below pointer */
788 list = &compositor->surface_list;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500789 if (compositor->fade.surface &&
790 list->next == &compositor->fade.surface->link)
791 list = list->next;
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500792 if (list->next == &input_device->sprite->link)
793 list = list->next;
794
795 return list;
796}
797
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500798static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500799weston_surface_raise(struct weston_surface *surface)
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400800{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500801 struct weston_compositor *compositor = surface->compositor;
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500802 struct wl_list *list = weston_compositor_top(compositor);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400803
804 wl_list_remove(&surface->link);
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500805 wl_list_insert(list, &surface->link);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500806 weston_compositor_repick(compositor);
807 weston_surface_damage(surface);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400808}
809
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400810WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500811weston_compositor_damage_all(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400812{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500813 struct weston_output *output;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400814
815 wl_list_for_each(output, &compositor->output_list, link)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500816 weston_output_damage(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400817}
818
Kristian Høgsberg9f404b72012-01-26 00:11:01 -0500819WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500820weston_buffer_post_release(struct wl_buffer *buffer)
Benjamin Franzke06286262011-05-06 19:12:33 +0200821{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400822 if (--buffer->busy_count > 0)
Benjamin Franzke06286262011-05-06 19:12:33 +0200823 return;
Benjamin Franzke06286262011-05-06 19:12:33 +0200824
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400825 assert(buffer->resource.client != NULL);
Kristian Høgsbergeccef6a2011-11-17 16:46:19 -0500826 wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
Benjamin Franzke06286262011-05-06 19:12:33 +0200827}
828
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400829WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500830weston_output_damage(struct weston_output *output)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400831{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500832 struct weston_compositor *compositor = output->compositor;
833 struct weston_surface *es;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400834
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500835 if (wl_list_empty(&compositor->surface_list))
836 return;
837
838 es = container_of(compositor->surface_list.next,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500839 struct weston_surface, link);
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500840 pixman_region32_union(&es->damage, &es->damage, &output->region);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500841 weston_compositor_schedule_repaint(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400842}
843
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400844static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500845fade_frame(struct weston_animation *animation,
846 struct weston_output *output, uint32_t msecs)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400847{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500848 struct weston_compositor *compositor =
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400849 container_of(animation,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500850 struct weston_compositor, fade.animation);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500851 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400852
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500853 surface = compositor->fade.surface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500854 weston_spring_update(&compositor->fade.spring, msecs);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500855 weston_surface_set_color(surface, 0.0, 0.0, 0.0,
856 compositor->fade.spring.current);
857 weston_surface_damage(surface);
858
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500859 if (weston_spring_done(&compositor->fade.spring)) {
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400860 compositor->fade.spring.current =
861 compositor->fade.spring.target;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400862 wl_list_remove(&animation->link);
863 wl_list_init(&animation->link);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200864
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500865 if (compositor->fade.spring.current < 0.001) {
866 destroy_surface(&surface->surface.resource);
867 compositor->fade.surface = NULL;
868 } else if (compositor->fade.spring.current > 0.999) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500869 compositor->state = WESTON_COMPOSITOR_SLEEPING;
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200870 compositor->shell->lock(compositor->shell);
871 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400872 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400873}
874
875static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500876weston_output_set_cursor(struct weston_output *output,
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500877 struct wl_input_device *dev)
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200878{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500879 struct weston_input_device *device =
880 (struct weston_input_device *) dev;
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200881 pixman_region32_t cursor_region;
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500882 int prior_was_hardware;
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200883
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -0500884 if (device->sprite == NULL)
885 return;
886
Pekka Paalanen3bfcd4d2012-01-26 11:31:01 +0200887 weston_surface_update_transform(device->sprite);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200888
Pekka Paalanen3bfcd4d2012-01-26 11:31:01 +0200889 pixman_region32_init(&cursor_region);
890 pixman_region32_intersect(&cursor_region,
891 &device->sprite->transform.boundingbox,
892 &output->region);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200893
894 if (!pixman_region32_not_empty(&cursor_region)) {
Ander Conselvan de Oliveira02924bc2011-10-24 16:30:15 +0300895 output->set_hardware_cursor(output, NULL);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200896 goto out;
897 }
898
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500899 prior_was_hardware = device->hw_cursor;
900 if (device->sprite->overlapped ||
901 output->set_hardware_cursor(output, device) < 0) {
Matt Roper11568a72011-08-29 15:59:37 -0700902 if (prior_was_hardware) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500903 weston_surface_damage(device->sprite);
Matt Roper11568a72011-08-29 15:59:37 -0700904 output->set_hardware_cursor(output, NULL);
905 }
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500906 device->hw_cursor = 0;
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500907 } else {
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500908 if (!prior_was_hardware)
909 weston_surface_damage_below(device->sprite);
910 pixman_region32_fini(&device->sprite->damage);
911 pixman_region32_init(&device->sprite->damage);
912 device->hw_cursor = 1;
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500913 }
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200914
915out:
916 pixman_region32_fini(&cursor_region);
917}
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400918
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500919struct weston_frame_callback {
920 struct wl_resource resource;
921 struct wl_list link;
922};
923
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400924static void
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500925weston_output_repaint(struct weston_output *output, int msecs)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400926{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500927 struct weston_compositor *ec = output->compositor;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500928 struct weston_surface *es;
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500929 struct weston_animation *animation, *next;
930 struct weston_frame_callback *cb, *cnext;
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500931 pixman_region32_t opaque, new_damage, total_damage,
932 overlap, surface_overlap;
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500933 int32_t width, height;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500934
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500935 width = output->current->width +
936 output->border.left + output->border.right;
937 height = output->current->height +
938 output->border.top + output->border.bottom;
939 glViewport(0, 0, width, height);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -0500940
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500941 pixman_region32_init(&new_damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400942 pixman_region32_init(&opaque);
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500943 pixman_region32_init(&overlap);
944
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400945 wl_list_for_each(es, &ec->surface_list, link) {
Pekka Paalanen15d60ef2012-01-27 14:38:33 +0200946 weston_surface_update_transform(es);
947
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500948 pixman_region32_init(&surface_overlap);
Pekka Paalanen15d60ef2012-01-27 14:38:33 +0200949 pixman_region32_intersect(&surface_overlap, &overlap,
950 &es->transform.boundingbox);
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500951 es->overlapped = pixman_region32_not_empty(&surface_overlap);
952 pixman_region32_fini(&surface_overlap);
Pekka Paalanen15d60ef2012-01-27 14:38:33 +0200953 pixman_region32_union(&overlap, &overlap,
954 &es->transform.boundingbox);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400955 }
956
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500957 weston_output_set_cursor(output, ec->input_device);
958
959 wl_list_for_each(es, &ec->surface_list, link) {
960 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
961 pixman_region32_union(&new_damage, &new_damage, &es->damage);
962 pixman_region32_union(&opaque, &opaque, &es->opaque);
963 }
964
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400965 pixman_region32_init(&total_damage);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500966 pixman_region32_union(&total_damage, &new_damage,
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400967 &output->previous_damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400968 pixman_region32_intersect(&output->previous_damage,
969 &new_damage, &output->region);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500970
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400971 pixman_region32_fini(&opaque);
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500972 pixman_region32_fini(&overlap);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -0400973 pixman_region32_fini(&new_damage);
974
Kristian Høgsbergac587412012-01-25 21:48:26 -0500975 wl_list_for_each(es, &ec->surface_list, link) {
976 pixman_region32_copy(&es->damage, &total_damage);
977 pixman_region32_subtract(&total_damage,
978 &total_damage, &es->opaque);
979 }
980
Kristian Høgsberg68c479a2012-01-25 23:32:28 -0500981 output->repaint(output);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400982
Pekka Paalanencc9102e2012-01-02 15:42:44 +0200983 pixman_region32_fini(&total_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500984
Kristian Høgsbergef044142011-06-21 15:02:12 -0400985 output->repaint_needed = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100986
Kristian Høgsberg33418202011-08-16 23:01:28 -0400987 wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) {
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400988 wl_resource_post_event(&cb->resource, WL_CALLBACK_DONE, msecs);
989 wl_resource_destroy(&cb->resource, 0);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500990 }
991
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500992 wl_list_for_each_safe(animation, next, &ec->animation_list, link)
Kristian Høgsbergef044142011-06-21 15:02:12 -0400993 animation->frame(animation, output, msecs);
994}
Kristian Høgsbergb1868472011-04-22 12:27:57 -0400995
Kristian Høgsbergef044142011-06-21 15:02:12 -0400996static void
997idle_repaint(void *data)
998{
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -0500999 struct weston_output *output = data;
1000
1001 /* An idle repaint may have been cancelled by vt switching away. */
1002 if (output->repaint_needed)
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001003 weston_output_repaint(output, weston_compositor_get_time());
Kristian Høgsberg2200d702012-01-26 08:47:04 -05001004 else
1005 output->repaint_scheduled = 0;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001006}
1007
1008WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001009weston_output_finish_frame(struct weston_output *output, int msecs)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001010{
Kristian Høgsbergef044142011-06-21 15:02:12 -04001011 if (output->repaint_needed)
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001012 weston_output_repaint(output, msecs);
Ander Conselvan de Oliveira22e22a52011-10-24 16:30:14 +03001013 else
1014 output->repaint_scheduled = 0;
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001015}
1016
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001017WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001018weston_compositor_schedule_repaint(struct weston_compositor *compositor)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001019{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001020 struct weston_output *output;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001021 struct wl_event_loop *loop;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001022
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001023 if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001024 return;
1025
Kristian Høgsbergef044142011-06-21 15:02:12 -04001026 loop = wl_display_get_event_loop(compositor->wl_display);
1027 wl_list_for_each(output, &compositor->output_list, link) {
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001028 output->repaint_needed = 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001029 if (output->repaint_scheduled)
1030 continue;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001031
Kristian Høgsbergef044142011-06-21 15:02:12 -04001032 wl_event_loop_add_idle(loop, idle_repaint, output);
1033 output->repaint_scheduled = 1;
1034 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001035}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -05001036
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001037WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001038weston_compositor_fade(struct weston_compositor *compositor, float tint)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001039{
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001040 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001041 int done;
1042
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001043 done = weston_spring_done(&compositor->fade.spring);
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001044 compositor->fade.spring.target = tint;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001045 if (weston_spring_done(&compositor->fade.spring))
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001046 return;
1047
1048 if (done)
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001049 compositor->fade.spring.timestamp =
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001050 weston_compositor_get_time();
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001051
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001052 if (compositor->fade.surface == NULL) {
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001053 surface = weston_surface_create(compositor);
1054 weston_surface_configure(surface, 0, 0, 8192, 8192);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001055 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0);
1056 wl_list_insert(&compositor->surface_list, &surface->link);
1057 compositor->fade.surface = surface;
1058 }
1059
1060 weston_surface_damage(compositor->fade.surface);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001061 if (wl_list_empty(&compositor->fade.animation.link))
1062 wl_list_insert(compositor->animation_list.prev,
1063 &compositor->fade.animation.link);
1064}
1065
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001066static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001067surface_destroy(struct wl_client *client, struct wl_resource *resource)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001068{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001069 wl_resource_destroy(resource, weston_compositor_get_time());
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001070}
1071
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001072WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001073weston_surface_assign_output(struct weston_surface *es)
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001074{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001075 struct weston_compositor *ec = es->compositor;
1076 struct weston_output *output, *new_output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001077 pixman_region32_t region;
1078 uint32_t max, area;
1079 pixman_box32_t *e;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001080
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001081 weston_surface_update_transform(es);
1082
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001083 new_output = NULL;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001084 max = 0;
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001085 pixman_region32_init(&region);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001086 wl_list_for_each(output, &ec->output_list, link) {
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001087 pixman_region32_intersect(&region, &es->transform.boundingbox,
1088 &output->region);
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001089
1090 e = pixman_region32_extents(&region);
1091 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1092
1093 if (area >= max) {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001094 new_output = output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001095 max = area;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001096 }
1097 }
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001098 pixman_region32_fini(&region);
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001099
1100 es->output = new_output;
1101 if (!wl_list_empty(&es->frame_callback_list)) {
1102 wl_list_insert_list(new_output->frame_callback_list.prev,
1103 &es->frame_callback_list);
1104 wl_list_init(&es->frame_callback_list);
1105 }
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001106}
1107
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001108static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001109surface_attach(struct wl_client *client,
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001110 struct wl_resource *resource,
Pekka Paalanena4f80f32012-01-31 12:04:54 +02001111 struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001112{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001113 struct weston_surface *es = resource->data;
1114 struct weston_shell *shell = es->compositor->shell;
Kristian Høgsbergd1e86252012-01-30 09:10:14 -05001115 struct wl_buffer *buffer;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001116
Kristian Høgsbergc5e23762012-01-06 14:37:19 -05001117 weston_surface_damage_below(es);
1118
Kristian Høgsberg24596942011-10-24 17:51:02 -04001119 if (es->buffer) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001120 weston_buffer_post_release(es->buffer);
Kristian Høgsberg24596942011-10-24 17:51:02 -04001121 wl_list_remove(&es->buffer_destroy_listener.link);
1122 }
Benjamin Franzke06286262011-05-06 19:12:33 +02001123
Kristian Høgsbergd1e86252012-01-30 09:10:14 -05001124 if (!buffer_resource && es->output) {
1125 wl_list_remove(&es->link);
1126 es->visual = WESTON_NONE_VISUAL;
1127 es->output = NULL;
1128 return;
1129 }
1130
1131 buffer = buffer_resource->data;
Kristian Høgsberg24596942011-10-24 17:51:02 -04001132 buffer->busy_count++;
Benjamin Franzke06286262011-05-06 19:12:33 +02001133 es->buffer = buffer;
Benjamin Franzke06286262011-05-06 19:12:33 +02001134 wl_list_insert(es->buffer->resource.destroy_listener_list.prev,
1135 &es->buffer_destroy_listener.link);
1136
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001137 if (es->visual == WESTON_NONE_VISUAL) {
Kristian Høgsberg32e24cc2011-11-09 12:07:35 -05001138 shell->map(shell, es, buffer->width, buffer->height);
Pekka Paalanena4f80f32012-01-31 12:04:54 +02001139 } else if (sx != 0 || sy != 0 ||
Pekka Paalanen60921e52012-01-25 15:55:43 +02001140 es->geometry.width != buffer->width ||
1141 es->geometry.height != buffer->height) {
Pekka Paalanenddae03c2012-02-06 14:54:20 +02001142 GLfloat from_x, from_y;
1143 GLfloat to_x, to_y;
Pekka Paalanena4f80f32012-01-31 12:04:54 +02001144
Pekka Paalanenddae03c2012-02-06 14:54:20 +02001145 surface_to_global_float(es, 0, 0, &from_x, &from_y);
1146 surface_to_global_float(es, sx, sy, &to_x, &to_y);
Pekka Paalanena4f80f32012-01-31 12:04:54 +02001147 shell->configure(shell, es,
1148 es->geometry.x + to_x - from_x,
1149 es->geometry.y + to_y - from_y,
Kristian Høgsberg32e24cc2011-11-09 12:07:35 -05001150 buffer->width, buffer->height);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001151 }
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001152
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001153 weston_buffer_attach(buffer, &es->surface);
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001154}
1155
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001156static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001157surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001158 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001159 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -05001160{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001161 struct weston_surface *es = resource->data;
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -04001162
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001163 weston_surface_damage_rectangle(es, x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001164}
1165
Kristian Høgsberg33418202011-08-16 23:01:28 -04001166static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001167destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001168{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001169 struct weston_frame_callback *cb = resource->data;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001170
1171 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02001172 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001173}
1174
1175static void
1176surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001177 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001178{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001179 struct weston_frame_callback *cb;
1180 struct weston_surface *es = resource->data;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001181
1182 cb = malloc(sizeof *cb);
1183 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001184 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001185 return;
1186 }
1187
1188 cb->resource.object.interface = &wl_callback_interface;
1189 cb->resource.object.id = callback;
1190 cb->resource.destroy = destroy_frame_callback;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001191 cb->resource.client = client;
1192 cb->resource.data = cb;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001193
1194 wl_client_add_resource(client, &cb->resource);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001195
1196 if (es->output) {
1197 wl_list_insert(es->output->frame_callback_list.prev,
1198 &cb->link);
1199 } else {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001200 wl_list_insert(es->frame_callback_list.prev, &cb->link);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001201 }
Kristian Høgsberg33418202011-08-16 23:01:28 -04001202}
1203
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001204const static struct wl_surface_interface surface_interface = {
1205 surface_destroy,
1206 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04001207 surface_damage,
1208 surface_frame
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001209};
1210
1211static void
1212compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001213 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001214{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001215 struct weston_compositor *ec = resource->data;
1216 struct weston_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001217
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001218 surface = weston_surface_create(ec);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001219 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001220 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001221 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001222 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001223
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001224 surface->surface.resource.destroy = destroy_surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001225
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001226 surface->surface.resource.object.id = id;
1227 surface->surface.resource.object.interface = &wl_surface_interface;
1228 surface->surface.resource.object.implementation =
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001229 (void (**)(void)) &surface_interface;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001230 surface->surface.resource.data = surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001231
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001232 wl_client_add_resource(client, &surface->surface.resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001233}
1234
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001235const static struct wl_compositor_interface compositor_interface = {
1236 compositor_create_surface,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001237};
1238
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001239WL_EXPORT struct weston_surface *
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001240weston_compositor_pick_surface(struct weston_compositor *compositor,
1241 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
Kristian Høgsberg773d13b2011-12-21 15:15:08 -05001242{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001243 struct weston_surface *surface;
Kristian Høgsberg773d13b2011-12-21 15:15:08 -05001244
1245 wl_list_for_each(surface, &compositor->surface_list, link) {
1246 if (surface->surface.resource.client == NULL)
1247 continue;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001248 weston_surface_from_global(surface, x, y, sx, sy);
Pekka Paalanen60921e52012-01-25 15:55:43 +02001249 if (0 <= *sx && *sx < surface->geometry.width &&
1250 0 <= *sy && *sy < surface->geometry.height)
Kristian Høgsberg773d13b2011-12-21 15:15:08 -05001251 return surface;
1252 }
1253
1254 return NULL;
1255}
1256
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001257WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001258weston_compositor_wake(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001259{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001260 compositor->state = WESTON_COMPOSITOR_ACTIVE;
1261 weston_compositor_fade(compositor, 0.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001262
1263 wl_event_source_timer_update(compositor->idle_source,
Pekka Paalanen7296e792011-12-07 16:22:00 +02001264 compositor->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001265}
1266
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001267WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001268weston_compositor_activity(struct weston_compositor *compositor)
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001269{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001270 if (compositor->state == WESTON_COMPOSITOR_ACTIVE) {
1271 weston_compositor_wake(compositor);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001272 } else {
1273 compositor->shell->unlock(compositor->shell);
1274 }
1275}
1276
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001277static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001278weston_compositor_idle_inhibit(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001279{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001280 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001281 compositor->idle_inhibit++;
1282}
1283
1284static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001285weston_compositor_idle_release(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001286{
1287 compositor->idle_inhibit--;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001288 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001289}
1290
1291static int
1292idle_handler(void *data)
1293{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001294 struct weston_compositor *compositor = data;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001295
1296 if (compositor->idle_inhibit)
1297 return 1;
1298
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001299 weston_compositor_fade(compositor, 1.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001300
1301 return 1;
1302}
1303
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001304WL_EXPORT void
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001305notify_motion(struct wl_input_device *device, uint32_t time, int x, int y)
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001306{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001307 struct weston_output *output;
Kristian Høgsberg6d65d5f2010-12-07 13:30:18 -05001308 const struct wl_grab_interface *interface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001309 struct weston_input_device *wd = (struct weston_input_device *) device;
1310 struct weston_compositor *ec = wd->compositor;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001311 int x_valid = 0, y_valid = 0;
1312 int min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN;
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001313
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001314 weston_compositor_activity(ec);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001315
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001316 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001317 if (output->x <= x && x <= output->x + output->current->width)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001318 x_valid = 1;
1319
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001320 if (output->y <= y && y <= output->y + output->current->height)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001321 y_valid = 1;
1322
1323 /* FIXME: calculate this only on output addition/deletion */
1324 if (output->x < min_x)
1325 min_x = output->x;
1326 if (output->y < min_y)
1327 min_y = output->y;
1328
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001329 if (output->x + output->current->width > max_x)
1330 max_x = output->x + output->current->width;
1331 if (output->y + output->current->height > max_y)
1332 max_y = output->y + output->current->height;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001333 }
1334
1335 if (!x_valid) {
1336 if (x < min_x)
1337 x = min_x;
1338 else if (x >= max_x)
1339 x = max_x;
1340 }
1341 if (!y_valid) {
1342 if (y < min_y)
1343 y = min_y;
1344 else if (y >= max_y)
1345 y = max_y;
1346 }
Ray Strode90e701d2008-12-18 23:05:43 -05001347
Kristian Høgsberge3ef3e52008-12-21 19:30:01 -05001348 device->x = x;
1349 device->y = y;
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -05001350
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001351 weston_device_repick(device, time);
1352 interface = device->grab->interface;
1353 interface->motion(device->grab, time,
1354 device->grab->x, device->grab->y);
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001355
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001356 if (wd->sprite) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001357 weston_surface_damage_below(wd->sprite);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001358
Pekka Paalanenba3cf952012-01-25 16:22:05 +02001359 wd->sprite->geometry.x = device->x - wd->hotspot_x;
1360 wd->sprite->geometry.y = device->y - wd->hotspot_y;
Pekka Paalanencd403622012-01-25 13:37:39 +02001361 wd->sprite->geometry.dirty = 1;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001362
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001363 weston_surface_damage(wd->sprite);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001364 }
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001365}
1366
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001367WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001368weston_surface_activate(struct weston_surface *surface,
1369 struct weston_input_device *device, uint32_t time)
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001370{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001371 weston_surface_raise(surface);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001372 wl_input_device_set_keyboard_focus(&device->input_device,
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001373 &surface->surface, time);
Kristian Høgsbergdade6492012-01-04 21:47:30 -05001374 wl_data_device_set_keyboard_focus(&device->input_device);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001375}
1376
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001377WL_EXPORT void
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001378notify_button(struct wl_input_device *device,
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001379 uint32_t time, int32_t button, int32_t state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001380{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001381 struct weston_input_device *wd = (struct weston_input_device *) device;
1382 struct weston_compositor *compositor = wd->compositor;
Kristian Høgsbergea081152010-12-07 08:59:51 -05001383
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001384 if (state) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001385 weston_compositor_idle_inhibit(compositor);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001386 if (device->button_count == 0) {
1387 device->grab_button = button;
1388 device->grab_time = time;
1389 device->grab_x = device->x;
1390 device->grab_y = device->y;
1391 }
1392 device->button_count++;
1393 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001394 weston_compositor_idle_release(compositor);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001395 device->button_count--;
1396 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001397
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001398 weston_compositor_run_binding(compositor, wd, time, 0, button, state);
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001399
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001400 device->grab->interface->button(device->grab, time, button, state);
Kristian Høgsberg5a5f0072011-12-19 14:54:11 -05001401
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001402}
1403
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001404static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001405update_modifier_state(struct weston_input_device *device,
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001406 uint32_t key, uint32_t state)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001407{
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001408 uint32_t modifier;
Kristian Høgsbergab909ae2001-01-01 22:24:24 -05001409
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001410 switch (key) {
1411 case KEY_LEFTCTRL:
1412 case KEY_RIGHTCTRL:
1413 modifier = MODIFIER_CTRL;
1414 break;
1415
1416 case KEY_LEFTALT:
1417 case KEY_RIGHTALT:
1418 modifier = MODIFIER_ALT;
1419 break;
1420
Kristian Høgsberg5b75f1b2010-08-04 23:21:41 -04001421 case KEY_LEFTMETA:
1422 case KEY_RIGHTMETA:
1423 modifier = MODIFIER_SUPER;
1424 break;
1425
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001426 default:
1427 modifier = 0;
1428 break;
1429 }
1430
1431 if (state)
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001432 device->modifier_state |= modifier;
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001433 else
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001434 device->modifier_state &= ~modifier;
1435}
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001436
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001437WL_EXPORT void
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001438notify_key(struct wl_input_device *device,
1439 uint32_t time, uint32_t key, uint32_t state)
1440{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001441 struct weston_input_device *wd = (struct weston_input_device *) device;
1442 struct weston_compositor *compositor = wd->compositor;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001443 uint32_t *k, *end;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001444
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001445 if (state)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001446 weston_compositor_idle_inhibit(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001447 else
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001448 weston_compositor_idle_release(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001449
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001450 weston_compositor_run_binding(compositor, wd, time, key, 0, state);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001451
1452 update_modifier_state(wd, key, state);
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001453 end = device->keys.data + device->keys.size;
1454 for (k = device->keys.data; k < end; k++) {
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001455 if (*k == key)
1456 *k = *--end;
1457 }
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001458 device->keys.size = (void *) end - device->keys.data;
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001459 if (state) {
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001460 k = wl_array_add(&device->keys, sizeof *k);
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001461 *k = key;
1462 }
Ray Strodee96dcb82008-12-20 02:00:49 -05001463
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001464 if (device->keyboard_focus_resource)
1465 wl_resource_post_event(device->keyboard_focus_resource,
1466 WL_INPUT_DEVICE_KEY, time, key, state);
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001467}
1468
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001469WL_EXPORT void
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001470notify_pointer_focus(struct wl_input_device *device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001471 uint32_t time, struct weston_output *output,
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001472 int32_t x, int32_t y)
1473{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001474 struct weston_input_device *wd = (struct weston_input_device *) device;
1475 struct weston_compositor *compositor = wd->compositor;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001476
1477 if (output) {
1478 device->x = x;
1479 device->y = y;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001480 compositor->focus = 1;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001481 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001482 } else {
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001483 compositor->focus = 0;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001484 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001485 }
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001486}
1487
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001488WL_EXPORT void
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001489notify_keyboard_focus(struct wl_input_device *device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001490 uint32_t time, struct weston_output *output,
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001491 struct wl_array *keys)
1492{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001493 struct weston_input_device *wd =
1494 (struct weston_input_device *) device;
1495 struct weston_compositor *compositor = wd->compositor;
1496 struct weston_surface *es;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001497 uint32_t *k, *end;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001498
1499 if (!wl_list_empty(&compositor->surface_list))
1500 es = container_of(compositor->surface_list.next,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001501 struct weston_surface, link);
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001502 else
1503 es = NULL;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001504
1505 if (output) {
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001506 wl_array_copy(&wd->input_device.keys, keys);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001507 wd->modifier_state = 0;
1508 end = device->keys.data + device->keys.size;
1509 for (k = device->keys.data; k < end; k++) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001510 weston_compositor_idle_inhibit(compositor);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001511 update_modifier_state(wd, *k, 1);
1512 }
1513
Kristian Høgsbergf59da392011-09-06 13:44:56 -04001514 if (es && es->surface.resource.client)
Benjamin Franzkeb7c00a42011-06-23 23:30:30 +02001515 wl_input_device_set_keyboard_focus(&wd->input_device,
1516 &es->surface, time);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001517 } else {
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001518 end = device->keys.data + device->keys.size;
1519 for (k = device->keys.data; k < end; k++)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001520 weston_compositor_idle_release(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001521
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001522 wd->modifier_state = 0;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001523 wl_input_device_set_keyboard_focus(&wd->input_device,
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001524 NULL, time);
1525 }
1526}
1527
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001528/* TODO: share this function with wayland-server.c */
1529static struct wl_resource *
1530find_resource_for_surface(struct wl_list *list, struct wl_surface *surface)
1531{
1532 struct wl_resource *r;
1533
1534 if (!surface)
1535 return NULL;
1536
1537 wl_list_for_each(r, list, link) {
1538 if (r->client == surface->resource.client)
1539 return r;
1540 }
1541
1542 return NULL;
1543}
1544
1545static void
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001546lose_touch_focus_resource(struct wl_listener *listener,
1547 struct wl_resource *resource, uint32_t time)
1548{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001549 struct weston_input_device *device =
1550 container_of(listener, struct weston_input_device,
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001551 touch_focus_resource_listener);
1552
1553 device->touch_focus_resource = NULL;
1554}
1555
1556static void
1557lose_touch_focus(struct wl_listener *listener,
1558 struct wl_resource *resource, uint32_t time)
1559{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001560 struct weston_input_device *device =
1561 container_of(listener, struct weston_input_device,
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001562 touch_focus_listener);
1563
1564 device->touch_focus = NULL;
1565}
1566
1567static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001568touch_set_focus(struct weston_input_device *device,
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001569 struct wl_surface *surface, uint32_t time)
1570{
1571 struct wl_input_device *input_device = &device->input_device;
1572 struct wl_resource *resource;
1573
1574 if (device->touch_focus == surface)
1575 return;
1576
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001577 if (surface) {
1578 resource =
1579 find_resource_for_surface(&input_device->resource_list,
1580 surface);
1581 if (!resource) {
1582 fprintf(stderr, "couldn't find resource\n");
1583 return;
1584 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001585
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001586 device->touch_focus_resource_listener.func =
1587 lose_touch_focus_resource;
1588 wl_list_insert(resource->destroy_listener_list.prev,
1589 &device->touch_focus_resource_listener.link);
1590 device->touch_focus_listener.func = lose_touch_focus;
1591 wl_list_insert(surface->resource.destroy_listener_list.prev,
1592 &device->touch_focus_listener.link);
1593
1594 device->touch_focus = surface;
1595 device->touch_focus_resource = resource;
1596 } else {
1597 if (device->touch_focus)
1598 wl_list_remove(&device->touch_focus_listener.link);
1599 if (device->touch_focus_resource)
1600 wl_list_remove(&device->touch_focus_resource_listener.link);
1601 device->touch_focus = NULL;
1602 device->touch_focus_resource = NULL;
1603 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001604}
1605
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001606/**
1607 * notify_touch - emulates button touches and notifies surfaces accordingly.
1608 *
1609 * It assumes always the correct cycle sequence until it gets here: touch_down
1610 * → touch_update → ... → touch_update → touch_end. The driver is responsible
1611 * for sending along such order.
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001612 *
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001613 */
1614WL_EXPORT void
1615notify_touch(struct wl_input_device *device, uint32_t time, int touch_id,
1616 int x, int y, int touch_type)
1617{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001618 struct weston_input_device *wd = (struct weston_input_device *) device;
1619 struct weston_compositor *ec = wd->compositor;
1620 struct weston_surface *es;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001621 int32_t sx, sy;
1622
1623 switch (touch_type) {
1624 case WL_INPUT_DEVICE_TOUCH_DOWN:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001625 weston_compositor_idle_inhibit(ec);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001626
1627 wd->num_tp++;
1628
1629 /* the first finger down picks the surface, and all further go
1630 * to that surface for the remainder of the touch session i.e.
1631 * until all touch points are up again. */
1632 if (wd->num_tp == 1) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001633 es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001634 touch_set_focus(wd, &es->surface, time);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001635 } else if (wd->touch_focus) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001636 es = (struct weston_surface *) wd->touch_focus;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001637 weston_surface_from_global(es, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001638 }
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001639
1640 if (wd->touch_focus_resource && wd->touch_focus)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001641 wl_resource_post_event(wd->touch_focus_resource,
1642 touch_type, time,
1643 wd->touch_focus,
1644 touch_id, sx, sy);
1645 break;
1646 case WL_INPUT_DEVICE_TOUCH_MOTION:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001647 es = (struct weston_surface *) wd->touch_focus;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001648 if (!es)
1649 break;
1650
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001651 weston_surface_from_global(es, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001652 if (wd->touch_focus_resource)
1653 wl_resource_post_event(wd->touch_focus_resource,
Kristian Høgsberg3543ff42011-12-21 17:25:54 -05001654 touch_type, time,
1655 touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001656 break;
1657 case WL_INPUT_DEVICE_TOUCH_UP:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001658 weston_compositor_idle_release(ec);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001659 wd->num_tp--;
1660
Kristian Høgsberg3543ff42011-12-21 17:25:54 -05001661 if (wd->touch_focus_resource)
1662 wl_resource_post_event(wd->touch_focus_resource,
1663 touch_type, time, touch_id);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001664 if (wd->num_tp == 0)
1665 touch_set_focus(wd, NULL, time);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001666 break;
1667 }
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001668}
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001669
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04001670static void
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001671input_device_attach(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001672 struct wl_resource *resource,
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001673 uint32_t time,
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001674 struct wl_resource *buffer_resource, int32_t x, int32_t y)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001675{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001676 struct weston_input_device *device = resource->data;
1677 struct weston_compositor *compositor = device->compositor;
Kristian Høgsberg57295eb2011-08-29 16:02:57 -04001678 struct wl_buffer *buffer;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001679
1680 if (time < device->input_device.pointer_focus_time)
1681 return;
1682 if (device->input_device.pointer_focus == NULL)
1683 return;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001684 if (device->input_device.pointer_focus->resource.client != client)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001685 return;
1686
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001687 if (device->sprite)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001688 weston_surface_damage_below(device->sprite);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001689
Kristian Høgsbergaded1f62012-02-08 16:33:57 -05001690 if (!buffer_resource && device->sprite->output) {
1691 wl_list_remove(&device->sprite->link);
1692 device->sprite->visual = WESTON_NONE_VISUAL;
1693 device->sprite->output = NULL;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001694 return;
1695 }
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001696
Kristian Høgsbergaded1f62012-02-08 16:33:57 -05001697 if (!device->sprite->output)
Kristian Høgsberga82c4862012-01-26 01:03:58 -05001698 wl_list_insert(&compositor->surface_list,
1699 &device->sprite->link);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001700
1701 buffer = buffer_resource->data;
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001702 device->hotspot_x = x;
1703 device->hotspot_y = y;
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001704 weston_surface_configure(device->sprite,
1705 device->input_device.x - device->hotspot_x,
1706 device->input_device.y - device->hotspot_y,
1707 buffer->width, buffer->height);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001708
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001709 weston_buffer_attach(buffer, &device->sprite->surface);
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001710}
1711
1712const static struct wl_input_device_interface input_device_interface = {
1713 input_device_attach,
1714};
1715
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001716static void unbind_input_device(struct wl_resource *resource)
1717{
1718 wl_list_remove(&resource->link);
1719 free(resource);
1720}
1721
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001722static void
1723bind_input_device(struct wl_client *client,
1724 void *data, uint32_t version, uint32_t id)
1725{
Kristian Høgsberg8e6d7122011-08-29 16:04:39 -04001726 struct wl_input_device *device = data;
1727 struct wl_resource *resource;
1728
1729 resource = wl_client_add_object(client, &wl_input_device_interface,
1730 &input_device_interface, id, data);
1731 wl_list_insert(&device->resource_list, &resource->link);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001732 resource->destroy = unbind_input_device;
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001733}
1734
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001735WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001736weston_input_device_init(struct weston_input_device *device,
1737 struct weston_compositor *ec)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001738{
Kristian Høgsberga8873122011-11-23 10:39:34 -05001739 wl_input_device_init(&device->input_device);
Kristian Høgsberg02ef1c12010-12-06 21:35:19 -05001740
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001741 wl_display_add_global(ec->wl_display, &wl_input_device_interface,
1742 device, bind_input_device);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001743
Kristian Høgsbergaded1f62012-02-08 16:33:57 -05001744 device->sprite = weston_surface_create(ec);
Kristian Høgsberg8244b442011-06-23 15:44:14 -04001745
Kristian Høgsberga8873122011-11-23 10:39:34 -05001746 device->compositor = ec;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04001747 device->hotspot_x = 16;
1748 device->hotspot_y = 16;
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001749 device->modifier_state = 0;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001750 device->num_tp = 0;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001751
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001752 wl_list_insert(ec->input_device_list.prev, &device->link);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001753}
1754
Pekka Paalanen07753fb2012-01-02 15:31:01 +02001755WL_EXPORT void
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05001756weston_input_device_release(struct weston_input_device *device)
Pekka Paalanen07753fb2012-01-02 15:31:01 +02001757{
1758 wl_list_remove(&device->link);
1759 /* The global object is destroyed at wl_display_destroy() time. */
1760
1761 if (device->sprite)
1762 destroy_surface(&device->sprite->surface.resource);
1763
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05001764 wl_input_device_release(&device->input_device);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02001765}
1766
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001767static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001768bind_output(struct wl_client *client,
1769 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05001770{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001771 struct weston_output *output = data;
1772 struct weston_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001773 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001774
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001775 resource = wl_client_add_object(client,
1776 &wl_output_interface, NULL, id, data);
1777
1778 wl_resource_post_event(resource,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001779 WL_OUTPUT_GEOMETRY,
1780 output->x,
1781 output->y,
1782 output->mm_width,
1783 output->mm_height,
1784 output->subpixel,
1785 output->make, output->model);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001786
1787 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001788 wl_resource_post_event(resource,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001789 WL_OUTPUT_MODE,
1790 mode->flags,
1791 mode->width,
1792 mode->height,
1793 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001794 }
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001795}
1796
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001797static const char vertex_shader[] =
1798 "uniform mat4 proj;\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05001799 "attribute vec2 position;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001800 "attribute vec2 texcoord;\n"
1801 "varying vec2 v_texcoord;\n"
1802 "void main()\n"
1803 "{\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05001804 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001805 " v_texcoord = texcoord;\n"
1806 "}\n";
1807
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001808static const char texture_fragment_shader[] =
Kristian Høgsbergdfce71d2010-12-07 20:19:10 -05001809 "precision mediump float;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001810 "varying vec2 v_texcoord;\n"
1811 "uniform sampler2D tex;\n"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05001812 "uniform float alpha;\n"
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001813 "uniform float texwidth;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001814 "void main()\n"
1815 "{\n"
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001816 " if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n"
1817 " v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n"
1818 " discard;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001819 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05001820 " gl_FragColor = alpha * gl_FragColor;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001821 "}\n";
1822
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001823static const char solid_fragment_shader[] =
1824 "precision mediump float;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001825 "uniform vec4 color;\n"
1826 "void main()\n"
1827 "{\n"
1828 " gl_FragColor = color\n;"
1829 "}\n";
1830
Kristian Høgsberga9468212010-06-14 21:03:11 -04001831static int
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001832compile_shader(GLenum type, const char *source)
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001833{
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001834 GLuint s;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001835 char msg[512];
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001836 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001837
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001838 s = glCreateShader(type);
1839 glShaderSource(s, 1, &source, NULL);
1840 glCompileShader(s);
1841 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001842 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001843 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
1844 fprintf(stderr, "shader info: %s\n", msg);
1845 return GL_NONE;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001846 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001847
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001848 return s;
1849}
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001850
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001851static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001852weston_shader_init(struct weston_shader *shader,
1853 const char *vertex_source, const char *fragment_source)
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001854{
1855 char msg[512];
1856 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001857
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001858 shader->vertex_shader =
1859 compile_shader(GL_VERTEX_SHADER, vertex_source);
1860 shader->fragment_shader =
1861 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
1862
1863 shader->program = glCreateProgram();
1864 glAttachShader(shader->program, shader->vertex_shader);
1865 glAttachShader(shader->program, shader->fragment_shader);
1866 glBindAttribLocation(shader->program, 0, "position");
1867 glBindAttribLocation(shader->program, 1, "texcoord");
1868
1869 glLinkProgram(shader->program);
1870 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001871 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001872 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001873 fprintf(stderr, "link info: %s\n", msg);
1874 return -1;
1875 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001876
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001877 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1878 shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
Kristian Høgsberg541e5552011-12-14 09:24:11 -05001879 shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
Pekka Paalanenf55f5442012-02-02 16:49:05 +02001880 shader->color_uniform = glGetUniformLocation(shader->program, "color");
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001881 shader->texwidth_uniform = glGetUniformLocation(shader->program,
1882 "texwidth");
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001883
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001884 return 0;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001885}
1886
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001887WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001888weston_output_destroy(struct weston_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001889{
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04001890 pixman_region32_fini(&output->region);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04001891 pixman_region32_fini(&output->previous_damage);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001892}
1893
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001894WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001895weston_output_move(struct weston_output *output, int x, int y)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001896{
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01001897 int flip;
1898
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001899 output->x = x;
1900 output->y = y;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001901
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04001902 pixman_region32_init(&output->previous_damage);
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04001903 pixman_region32_init_rect(&output->region, x, y,
1904 output->current->width,
1905 output->current->height);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001906
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001907 weston_matrix_init(&output->matrix);
1908 weston_matrix_translate(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05001909 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
1910 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01001911
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001912 flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001913 weston_matrix_scale(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05001914 2.0 / (output->current->width + output->border.left + output->border.right),
1915 flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001916
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001917 weston_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001918}
1919
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001920WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001921weston_output_init(struct weston_output *output, struct weston_compositor *c,
1922 int x, int y, int width, int height, uint32_t flags)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001923{
1924 output->compositor = c;
1925 output->x = x;
1926 output->y = y;
Kristian Høgsberg546a8122012-02-01 07:45:51 -05001927 output->border.top = 0;
1928 output->border.bottom = 0;
1929 output->border.left = 0;
1930 output->border.right = 0;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001931 output->mm_width = width;
1932 output->mm_height = height;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001933
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001934 output->flags = flags;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001935 weston_output_move(output, x, y);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001936
Kristian Høgsberg33418202011-08-16 23:01:28 -04001937 wl_list_init(&output->frame_callback_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02001938
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001939 wl_display_add_global(c->wl_display,
1940 &wl_output_interface, output, bind_output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001941}
1942
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001943static void
1944shm_buffer_created(struct wl_buffer *buffer)
1945{
1946 struct wl_list *surfaces_attached_to;
1947
1948 surfaces_attached_to = malloc(sizeof *surfaces_attached_to);
1949 if (!surfaces_attached_to) {
1950 buffer->user_data = NULL;
1951 return;
1952 }
1953
1954 wl_list_init(surfaces_attached_to);
1955
1956 buffer->user_data = surfaces_attached_to;
1957}
1958
1959static void
1960shm_buffer_damaged(struct wl_buffer *buffer,
1961 int32_t x, int32_t y, int32_t width, int32_t height)
1962{
1963 struct wl_list *surfaces_attached_to = buffer->user_data;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001964 struct weston_surface *es;
Benjamin Franzkefab5ec12011-04-25 19:44:47 +02001965 GLsizei tex_width = wl_shm_buffer_get_stride(buffer) / 4;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001966
1967 wl_list_for_each(es, surfaces_attached_to, buffer_link) {
1968 glBindTexture(GL_TEXTURE_2D, es->texture);
1969 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Benjamin Franzkefab5ec12011-04-25 19:44:47 +02001970 tex_width, buffer->height, 0,
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001971 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1972 wl_shm_buffer_get_data(buffer));
1973 /* Hmm, should use glTexSubImage2D() here but GLES2 doesn't
1974 * support any unpack attributes except GL_UNPACK_ALIGNMENT. */
1975 }
1976}
1977
1978static void
1979shm_buffer_destroyed(struct wl_buffer *buffer)
1980{
1981 struct wl_list *surfaces_attached_to = buffer->user_data;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001982 struct weston_surface *es, *next;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001983
1984 wl_list_for_each_safe(es, next, surfaces_attached_to, buffer_link) {
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001985 wl_list_remove(&es->buffer_link);
Kristian Høgsbergfac11d22011-05-02 13:35:17 -04001986 wl_list_init(&es->buffer_link);
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001987 }
1988
1989 free(surfaces_attached_to);
1990}
1991
1992const static struct wl_shm_callbacks shm_callbacks = {
1993 shm_buffer_created,
1994 shm_buffer_damaged,
1995 shm_buffer_destroyed
1996};
1997
Kristian Høgsberga8873122011-11-23 10:39:34 -05001998static void
1999compositor_bind(struct wl_client *client,
2000 void *data, uint32_t version, uint32_t id)
2001{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002002 struct weston_compositor *compositor = data;
Kristian Høgsberga8873122011-11-23 10:39:34 -05002003
2004 wl_client_add_object(client, &wl_compositor_interface,
2005 &compositor_interface, id, compositor);
2006}
2007
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002008WL_EXPORT int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002009weston_compositor_init(struct weston_compositor *ec, struct wl_display *display)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002010{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002011 struct wl_event_loop *loop;
Kristian Høgsbergd711d0c2011-01-14 17:28:21 -05002012 const char *extensions;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002013
Kristian Høgsbergf9212892008-10-11 18:40:23 -04002014 ec->wl_display = display;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002015
Kristian Høgsberga8873122011-11-23 10:39:34 -05002016 if (!wl_display_add_global(display, &wl_compositor_interface,
2017 ec, compositor_bind))
2018 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05002019
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002020 ec->shm = wl_shm_init(display, &shm_callbacks);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002021
2022 ec->image_target_texture_2d =
2023 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
2024 ec->image_target_renderbuffer_storage = (void *)
2025 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
2026 ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
2027 ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
2028 ec->bind_display =
2029 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
2030 ec->unbind_display =
2031 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
2032
2033 extensions = (const char *) glGetString(GL_EXTENSIONS);
2034 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
2035 fprintf(stderr,
2036 "GL_EXT_texture_format_BGRA8888 not available\n");
2037 return -1;
2038 }
2039
2040 extensions =
2041 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
2042 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
2043 ec->has_bind_display = 1;
2044 if (ec->has_bind_display)
2045 ec->bind_display(ec->display, ec->wl_display);
Kristian Høgsberg3d5bae02010-10-06 21:17:40 -04002046
Kristian Høgsberg201a9042008-12-10 00:40:50 -05002047 wl_list_init(&ec->surface_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002048 wl_list_init(&ec->input_device_list);
2049 wl_list_init(&ec->output_list);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002050 wl_list_init(&ec->binding_list);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002051 wl_list_init(&ec->animation_list);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002052 weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002053 ec->fade.animation.frame = fade_frame;
2054 wl_list_init(&ec->fade.animation.link);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002055
Pekka Paalanen35ce06d2012-01-03 11:39:13 +02002056 ec->screenshooter = screenshooter_create(ec);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002057
Kristian Høgsbergdade6492012-01-04 21:47:30 -05002058 wl_data_device_manager_init(ec->wl_display);
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002059
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002060 glActiveTexture(GL_TEXTURE0);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002061
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002062 if (weston_shader_init(&ec->texture_shader,
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002063 vertex_shader, texture_fragment_shader) < 0)
Kristian Høgsberga9468212010-06-14 21:03:11 -04002064 return -1;
Pekka Paalanenf55f5442012-02-02 16:49:05 +02002065 if (weston_shader_init(&ec->solid_shader,
2066 vertex_shader, solid_fragment_shader) < 0)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002067 return -1;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05002068
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002069 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002070 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
Pekka Paalanen7296e792011-12-07 16:22:00 +02002071 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002072
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002073 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04002074
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002075 return 0;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002076}
2077
Benjamin Franzkeb8263022011-08-30 11:32:47 +02002078WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002079weston_compositor_shutdown(struct weston_compositor *ec)
Matt Roper361d2ad2011-08-29 13:52:23 -07002080{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002081 struct weston_output *output, *next;
Matt Roper361d2ad2011-08-29 13:52:23 -07002082
Pekka Paalanend1591ae2012-01-02 16:06:56 +02002083 wl_event_source_remove(ec->idle_source);
2084
Pekka Paalanen35ce06d2012-01-03 11:39:13 +02002085 if (ec->screenshooter)
2086 screenshooter_destroy(ec->screenshooter);
2087
Matt Roper361d2ad2011-08-29 13:52:23 -07002088 /* Destroy all outputs associated with this compositor */
Tiago Vignattib303a1d2011-12-18 22:27:40 +02002089 wl_list_for_each_safe(output, next, &ec->output_list, link)
Matt Roper361d2ad2011-08-29 13:52:23 -07002090 output->destroy(output);
Pekka Paalanen4738f3b2012-01-02 15:47:07 +02002091
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05002092 weston_binding_list_destroy_all(&ec->binding_list);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02002093
2094 wl_shm_finish(ec->shm);
2095
2096 wl_array_release(&ec->vertices);
2097 wl_array_release(&ec->indices);
Matt Roper361d2ad2011-08-29 13:52:23 -07002098}
2099
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002100static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002101{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002102 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002103
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002104 fprintf(stderr, "caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002105 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002106
2107 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002108}
2109
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002110static void
2111on_segv_signal(int s, siginfo_t *siginfo, void *context)
2112{
2113 void *buffer[32];
2114 int i, count;
2115 Dl_info info;
2116
2117 fprintf(stderr, "caught segv\n");
2118
2119 count = backtrace(buffer, ARRAY_LENGTH(buffer));
2120 for (i = 0; i < count; i++) {
2121 dladdr(buffer[i], &info);
2122 fprintf(stderr, " [%016lx] %s (%s)\n",
2123 (long) buffer[i],
2124 info.dli_sname ? info.dli_sname : "--",
2125 info.dli_fname);
2126 }
2127
2128 longjmp(segv_jmp_buf, 1);
2129}
2130
2131
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002132static void *
2133load_module(const char *name, const char *entrypoint, void **handle)
2134{
2135 char path[PATH_MAX];
2136 void *module, *init;
2137
2138 if (name[0] != '/')
2139 snprintf(path, sizeof path, MODULEDIR "/%s", name);
2140 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02002141 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002142
2143 module = dlopen(path, RTLD_LAZY);
2144 if (!module) {
2145 fprintf(stderr,
2146 "failed to load module: %s\n", dlerror());
2147 return NULL;
2148 }
2149
2150 init = dlsym(module, entrypoint);
2151 if (!init) {
2152 fprintf(stderr,
2153 "failed to lookup init function: %s\n", dlerror());
2154 return NULL;
2155 }
2156
2157 return init;
2158}
2159
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002160int main(int argc, char *argv[])
2161{
2162 struct wl_display *display;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002163 struct weston_compositor *ec;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002164 struct wl_event_source *signals[4];
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002165 struct wl_event_loop *loop;
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002166 struct sigaction segv_action;
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002167 int o, xserver = 0;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002168 void *shell_module, *backend_module;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002169 int (*shell_init)(struct weston_compositor *ec);
2170 struct weston_compositor
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002171 *(*backend_init)(struct wl_display *display, char *options);
2172 char *backend = NULL;
2173 char *backend_options = "";
2174 char *shell = NULL;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002175 char *p;
Pekka Paalanen7296e792011-12-07 16:22:00 +02002176 int option_idle_time = 300;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002177 int i;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002178
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002179 static const char opts[] = "B:b:o:S:i:s:x";
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002180 static const struct option longopts[ ] = {
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002181 { "backend", 1, NULL, 'B' },
2182 { "backend-options", 1, NULL, 'o' },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002183 { "socket", 1, NULL, 'S' },
2184 { "idle-time", 1, NULL, 'i' },
2185 { "shell", 1, NULL, 's' },
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002186 { "xserver", 0, NULL, 'x' },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002187 { NULL, }
2188 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05002189
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002190 while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) {
2191 switch (o) {
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002192 case 'B':
2193 backend = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002194 break;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002195 case 'o':
2196 backend_options = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002197 break;
2198 case 'S':
2199 option_socket_name = optarg;
2200 break;
2201 case 'i':
2202 option_idle_time = strtol(optarg, &p, 0);
2203 if (*p != '\0') {
2204 fprintf(stderr,
2205 "invalid idle time option: %s\n",
2206 optarg);
2207 exit(EXIT_FAILURE);
2208 }
2209 break;
2210 case 's':
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002211 shell = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002212 break;
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002213 case 'x':
2214 xserver = 1;
2215 break;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002216 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04002217 }
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002218
2219 display = wl_display_create();
2220
Tiago Vignatti2116b892011-08-08 05:52:59 -07002221 loop = wl_display_get_event_loop(display);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002222 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
2223 display);
2224 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
2225 display);
2226 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
2227 display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07002228
2229 wl_list_init(&child_process_list);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002230 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
2231 NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05002232
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002233 segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
2234 segv_action.sa_sigaction = on_segv_signal;
Pekka Paalanen8423a892012-01-19 16:48:37 +02002235 sigemptyset(&segv_action.sa_mask);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002236 sigaction(SIGSEGV, &segv_action, NULL);
2237
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002238 if (!backend) {
2239 if (getenv("WAYLAND_DISPLAY"))
2240 backend = "wayland-backend.so";
2241 else if (getenv("DISPLAY"))
2242 backend = "x11-backend.so";
2243 else if (getenv("OPENWFD"))
2244 backend = "openwfd-backend.so";
2245 else
2246 backend = "drm-backend.so";
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04002247 }
2248
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002249 if (!shell)
2250 shell = "desktop-shell.so";
Kristian Høgsberga9410222011-01-14 17:22:35 -05002251
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002252 backend_init = load_module(backend, "backend_init", &backend_module);
2253 if (!backend_init)
2254 exit(EXIT_FAILURE);
Kristian Høgsberga9410222011-01-14 17:22:35 -05002255
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002256 shell_init = load_module(shell, "shell_init", &shell_module);
2257 if (!shell_init)
2258 exit(EXIT_FAILURE);
Benjamin Franzke5d007092011-04-04 00:30:25 +02002259
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002260 ec = backend_init(display, backend_options);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05002261 if (ec == NULL) {
2262 fprintf(stderr, "failed to create compositor\n");
2263 exit(EXIT_FAILURE);
2264 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04002265
Pekka Paalanen7296e792011-12-07 16:22:00 +02002266 ec->option_idle_time = option_idle_time;
2267 ec->idle_time = option_idle_time;
2268
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002269 if (xserver)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002270 weston_xserver_init(ec);
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002271
Kristian Høgsberg1760ebb2012-01-15 16:04:33 -05002272 if (shell_init(ec) < 0)
2273 exit(EXIT_FAILURE);
2274
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05002275 if (wl_display_add_socket(display, option_socket_name)) {
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002276 fprintf(stderr, "failed to add socket: %m\n");
2277 exit(EXIT_FAILURE);
2278 }
2279
Pekka Paalanenc0444e32012-01-05 16:28:21 +02002280 weston_compositor_wake(ec);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002281 if (setjmp(segv_jmp_buf) == 0)
2282 wl_display_run(display);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002283
Pekka Paalanen0135abe2012-01-03 10:01:20 +02002284 /* prevent further rendering while shutting down */
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05002285 ec->state = WESTON_COMPOSITOR_SLEEPING;
Pekka Paalanen0135abe2012-01-03 10:01:20 +02002286
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002287 if (xserver)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002288 weston_xserver_destroy(ec);
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002289
Pekka Paalanen3c647232011-12-22 13:43:43 +02002290 ec->shell->destroy(ec->shell);
2291
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002292 if (ec->has_bind_display)
2293 ec->unbind_display(ec->display, display);
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05002294
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002295 for (i = ARRAY_LENGTH(signals); i;)
2296 wl_event_source_remove(signals[--i]);
2297
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002298 ec->destroy(ec);
Tiago Vignatti9e2be082011-12-19 00:04:46 +02002299 wl_display_destroy(display);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002300
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002301 return 0;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002302}