blob: 80ee2ba29b437e4e8af891e39760192a8a2fe550 [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øgsberg5e7e6f22012-02-23 16:11:59 -0500178static const pixman_region32_data_t undef_region_data;
179
180static void
181undef_region(pixman_region32_t *region)
182{
183 pixman_region32_fini(region);
184 region->data = (pixman_region32_data_t *) &undef_region_data;
185}
186
187static int
188region_is_undefined(pixman_region32_t *region)
189{
190 return region->data == &undef_region_data;
191}
192
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500193WL_EXPORT struct weston_surface *
Kristian Høgsberg18c93002012-01-27 11:58:31 -0500194weston_surface_create(struct weston_compositor *compositor)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500195{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500196 struct weston_surface *surface;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400197
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200198 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400199 if (surface == NULL)
200 return NULL;
201
Kristian Høgsbergf6b14712011-01-06 15:32:14 -0500202 wl_list_init(&surface->link);
Benjamin Franzkebab41fb2011-03-07 18:04:59 +0100203 wl_list_init(&surface->buffer_link);
Kristian Høgsbergc551bd22010-12-06 16:43:16 -0500204
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400205 surface->surface.resource.client = NULL;
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400206
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500207 surface->compositor = compositor;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200208 surface->image = EGL_NO_IMAGE_KHR;
Kristian Høgsberg541e5552011-12-14 09:24:11 -0500209 surface->alpha = 255;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400210
Benjamin Franzke06286262011-05-06 19:12:33 +0200211 surface->buffer = NULL;
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400212 surface->output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200213
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400214 pixman_region32_init(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500215 pixman_region32_init(&surface->opaque);
216 undef_region(&surface->input);
Pekka Paalanen730d87e2012-02-09 16:39:38 +0200217 pixman_region32_init(&surface->transform.opaque);
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500218 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400219
Benjamin Franzke06286262011-05-06 19:12:33 +0200220 surface->buffer_destroy_listener.func = surface_handle_buffer_destroy;
Benjamin Franzke06286262011-05-06 19:12:33 +0200221
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200222 wl_list_init(&surface->geometry.transformation_list);
Pekka Paalanencd403622012-01-25 13:37:39 +0200223 wl_list_insert(&surface->geometry.transformation_list,
224 &surface->transform.position.link);
225 weston_matrix_init(&surface->transform.position.matrix);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200226 pixman_region32_init(&surface->transform.boundingbox);
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200227 surface->geometry.dirty = 1;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500228
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400229 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500230}
231
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500232static void
233weston_surface_set_color(struct weston_surface *surface,
234 GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
235{
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500236 surface->color[0] = red;
237 surface->color[1] = green;
238 surface->color[2] = blue;
239 surface->color[3] = alpha;
240 surface->shader = &surface->compositor->solid_shader;
241}
242
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200243static void
Pekka Paalanenece8a012012-02-08 15:23:15 +0200244surface_to_global_float(struct weston_surface *surface,
245 int32_t sx, int32_t sy, GLfloat *x, GLfloat *y)
246{
247 if (surface->transform.enabled) {
248 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
249
250 weston_matrix_transform(&surface->transform.matrix, &v);
251
252 if (fabsf(v.f[3]) < 1e-6) {
253 fprintf(stderr, "warning: numerical instability in "
254 "weston_surface_to_global(), divisor = %g\n",
255 v.f[3]);
256 *x = 0;
257 *y = 0;
258 return;
259 }
260
261 *x = v.f[0] / v.f[3];
262 *y = v.f[1] / v.f[3];
263 } else {
264 *x = sx + surface->geometry.x;
265 *y = sy + surface->geometry.y;
266 }
267}
268
269static void
Kristian Høgsberg323ee042012-02-17 12:45:43 -0500270weston_surface_damage_below(struct weston_surface *surface)
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200271{
272 struct weston_surface *below;
273
274 if (surface->output == NULL)
275 return;
276
277 if (surface->link.next == &surface->compositor->surface_list)
278 return;
279
280 below = container_of(surface->link.next, struct weston_surface, link);
281 pixman_region32_union(&below->damage, &below->damage,
282 &surface->transform.boundingbox);
283}
284
285static void
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200286surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy,
287 int32_t width, int32_t height,
288 pixman_region32_t *bbox)
289{
Pekka Paalanen219b9822012-02-08 15:38:37 +0200290 GLfloat min_x = HUGE_VALF, min_y = HUGE_VALF;
291 GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200292 int32_t s[4][2] = {
293 { sx, sy },
294 { sx, sy + height },
295 { sx + width, sy },
296 { sx + width, sy + height }
297 };
Pekka Paalanen219b9822012-02-08 15:38:37 +0200298 GLfloat int_x, int_y;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200299 int i;
300
301 for (i = 0; i < 4; ++i) {
Pekka Paalanen219b9822012-02-08 15:38:37 +0200302 GLfloat x, y;
303 surface_to_global_float(surface, s[i][0], s[i][1], &x, &y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200304 if (x < min_x)
305 min_x = x;
306 if (x > max_x)
307 max_x = x;
308 if (y < min_y)
309 min_y = y;
310 if (y > max_y)
311 max_y = y;
312 }
313
Pekka Paalanen219b9822012-02-08 15:38:37 +0200314 int_x = floorf(min_x);
315 int_y = floorf(min_y);
316 pixman_region32_init_rect(bbox, int_x, int_y,
317 ceilf(max_x) - int_x, ceilf(max_y) - int_y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200318}
319
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200320static void
321weston_surface_update_transform_disable(struct weston_surface *surface)
322{
323 surface->transform.enabled = 0;
324
Pekka Paalanencc2f8682012-02-13 10:34:04 +0200325 /* round off fractions when not transformed */
326 surface->geometry.x = roundf(surface->geometry.x);
327 surface->geometry.y = roundf(surface->geometry.y);
328
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200329 pixman_region32_init_rect(&surface->transform.boundingbox,
330 surface->geometry.x,
331 surface->geometry.y,
332 surface->geometry.width,
333 surface->geometry.height);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500334
335 pixman_region32_copy(&surface->transform.opaque, &surface->opaque);
336 pixman_region32_translate(&surface->transform.opaque,
337 surface->geometry.x, surface->geometry.y);
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200338}
339
340static int
341weston_surface_update_transform_enable(struct weston_surface *surface)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200342{
343 struct weston_matrix *matrix = &surface->transform.matrix;
344 struct weston_matrix *inverse = &surface->transform.inverse;
345 struct weston_transform *tform;
346
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200347 surface->transform.enabled = 1;
348
349 /* Otherwise identity matrix, but with x and y translation. */
350 surface->transform.position.matrix.d[12] = surface->geometry.x;
351 surface->transform.position.matrix.d[13] = surface->geometry.y;
352
353 weston_matrix_init(matrix);
354 wl_list_for_each(tform, &surface->geometry.transformation_list, link)
355 weston_matrix_multiply(matrix, &tform->matrix);
356
357 if (weston_matrix_invert(inverse, matrix) < 0) {
358 /* Oops, bad total transformation, not invertible */
359 fprintf(stderr, "error: weston_surface %p"
360 " transformation not invertible.\n", surface);
361 return -1;
362 }
363
364 surface_compute_bbox(surface, 0, 0, surface->geometry.width,
365 surface->geometry.height,
366 &surface->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500367
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200368 return 0;
369}
370
371WL_EXPORT void
372weston_surface_update_transform(struct weston_surface *surface)
373{
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200374 if (!surface->geometry.dirty)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200375 return;
376
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200377 surface->geometry.dirty = 0;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200378
Kristian Høgsberg323ee042012-02-17 12:45:43 -0500379 weston_surface_damage_below(surface);
Pekka Paalanen96516782012-02-09 15:32:15 +0200380
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200381 pixman_region32_fini(&surface->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500382 pixman_region32_fini(&surface->transform.opaque);
383 pixman_region32_init(&surface->transform.opaque);
384
385 if (region_is_undefined(&surface->input))
386 pixman_region32_init_rect(&surface->input, 0, 0,
387 surface->geometry.width,
388 surface->geometry.height);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200389
Pekka Paalanencd403622012-01-25 13:37:39 +0200390 /* transform.position is always in transformation_list */
391 if (surface->geometry.transformation_list.next ==
392 &surface->transform.position.link &&
393 surface->geometry.transformation_list.prev ==
394 &surface->transform.position.link) {
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200395 weston_surface_update_transform_disable(surface);
396 } else {
397 if (weston_surface_update_transform_enable(surface) < 0)
398 weston_surface_update_transform_disable(surface);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200399 }
Pekka Paalanen96516782012-02-09 15:32:15 +0200400
401 /* weston_surface_damage() without update */
402 pixman_region32_union(&surface->damage, &surface->damage,
403 &surface->transform.boundingbox);
404
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +0200405 if (surface->output)
406 weston_surface_assign_output(surface);
407
Pekka Paalanen96516782012-02-09 15:32:15 +0200408 weston_compositor_schedule_repaint(surface->compositor);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200409}
410
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200411WL_EXPORT void
412weston_surface_to_global(struct weston_surface *surface,
413 int32_t sx, int32_t sy, int32_t *x, int32_t *y)
414{
415 GLfloat xf, yf;
416
417 weston_surface_update_transform(surface);
418
419 surface_to_global_float(surface, sx, sy, &xf, &yf);
420 *x = floorf(xf);
421 *y = floorf(yf);
422}
423
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200424static void
425surface_from_global_float(struct weston_surface *surface,
426 int32_t x, int32_t y, GLfloat *sx, GLfloat *sy)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200427{
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200428 if (surface->transform.enabled) {
429 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
430
431 weston_matrix_transform(&surface->transform.inverse, &v);
432
433 if (fabsf(v.f[3]) < 1e-6) {
434 fprintf(stderr, "warning: numerical instability in "
435 "weston_surface_from_global(), divisor = %g\n",
436 v.f[3]);
437 *sx = 0;
438 *sy = 0;
439 return;
440 }
441
Pekka Paalanencd403622012-01-25 13:37:39 +0200442 *sx = v.f[0] / v.f[3];
443 *sy = v.f[1] / v.f[3];
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200444 } else {
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200445 *sx = x - surface->geometry.x;
446 *sy = y - surface->geometry.y;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200447 }
448}
449
450WL_EXPORT void
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200451weston_surface_from_global(struct weston_surface *surface,
452 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
453{
454 GLfloat sxf, syf;
455
456 weston_surface_update_transform(surface);
457
458 surface_from_global_float(surface, x, y, &sxf, &syf);
459 *sx = floorf(sxf);
460 *sy = floorf(syf);
461}
462
Tiago Vignatti9d393522012-02-10 16:26:19 +0200463static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500464weston_surface_damage_rectangle(struct weston_surface *surface,
Pekka Paalanen2267d452012-01-26 13:12:45 +0200465 int32_t sx, int32_t sy,
466 int32_t width, int32_t height)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500467{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200468 weston_surface_update_transform(surface);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500469
Pekka Paalanen2267d452012-01-26 13:12:45 +0200470 if (surface->transform.enabled) {
471 pixman_region32_t box;
472 surface_compute_bbox(surface, sx, sy, width, height, &box);
473 pixman_region32_union(&surface->damage, &surface->damage,
474 &box);
475 pixman_region32_fini(&box);
476 } else {
Pekka Paalanen2267d452012-01-26 13:12:45 +0200477 pixman_region32_union_rect(&surface->damage, &surface->damage,
Pekka Paalanen1d5035c2012-02-09 15:27:45 +0200478 surface->geometry.x + sx,
479 surface->geometry.y + sy,
480 width, height);
Pekka Paalanen2267d452012-01-26 13:12:45 +0200481 }
482
483 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500484}
485
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400486WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500487weston_surface_damage(struct weston_surface *surface)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500488{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200489 weston_surface_update_transform(surface);
490
491 pixman_region32_union(&surface->damage, &surface->damage,
492 &surface->transform.boundingbox);
493
494 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500495}
496
Tiago Vignatti9d393522012-02-10 16:26:19 +0200497static void
Kristian Høgsberg90b53812012-01-18 21:41:37 -0500498weston_surface_flush_damage(struct weston_surface *surface)
499{
500 struct weston_surface *below;
501
502 if (surface->output &&
503 surface->link.next != &surface->compositor->surface_list) {
504 below = container_of(surface->link.next,
505 struct weston_surface, link);
506
507 pixman_region32_union(&below->damage,
508 &below->damage, &surface->damage);
509 }
510}
511
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400512WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500513weston_surface_configure(struct weston_surface *surface,
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200514 GLfloat x, GLfloat y, int width, int height)
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400515{
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200516 surface->geometry.x = x;
517 surface->geometry.y = y;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200518 surface->geometry.width = width;
519 surface->geometry.height = height;
Pekka Paalanencd403622012-01-25 13:37:39 +0200520 surface->geometry.dirty = 1;
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400521}
522
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +0200523WL_EXPORT void
524weston_surface_set_position(struct weston_surface *surface,
525 GLfloat x, GLfloat y)
526{
527 surface->geometry.x = x;
528 surface->geometry.y = y;
529 surface->geometry.dirty = 1;
530}
531
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400532WL_EXPORT uint32_t
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500533weston_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500534{
535 struct timeval tv;
536
537 gettimeofday(&tv, NULL);
538
539 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
540}
541
Tiago Vignatti9d393522012-02-10 16:26:19 +0200542static struct weston_surface *
543weston_compositor_pick_surface(struct weston_compositor *compositor,
544 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
545{
546 struct weston_surface *surface;
547
548 wl_list_for_each(surface, &compositor->surface_list, link) {
Tiago Vignatti9d393522012-02-10 16:26:19 +0200549 weston_surface_from_global(surface, x, y, sx, sy);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500550 if (pixman_region32_contains_point(&surface->input,
551 *sx, *sy, NULL))
Tiago Vignatti9d393522012-02-10 16:26:19 +0200552 return surface;
553 }
554
555 return NULL;
556}
557
558static void
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500559weston_device_repick(struct wl_input_device *device, uint32_t time)
560{
561 struct weston_input_device *wd = (struct weston_input_device *) device;
Scott Moreau447013d2012-02-18 05:05:29 -0700562 const struct wl_pointer_grab_interface *interface;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500563 struct weston_surface *surface, *focus;
564
565 surface = weston_compositor_pick_surface(wd->compositor,
566 device->x, device->y,
567 &device->current_x,
568 &device->current_y);
569
570 if (&surface->surface != device->current) {
Scott Moreau447013d2012-02-18 05:05:29 -0700571 interface = device->pointer_grab->interface;
572 interface->focus(device->pointer_grab, time, &surface->surface,
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500573 device->current_x, device->current_y);
574 device->current = &surface->surface;
575 }
576
Scott Moreau447013d2012-02-18 05:05:29 -0700577 focus = (struct weston_surface *) device->pointer_grab->focus;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500578 if (focus)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200579 weston_surface_from_global(focus, device->x, device->y,
Scott Moreau447013d2012-02-18 05:05:29 -0700580 &device->pointer_grab->x, &device->pointer_grab->y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500581}
582
583WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500584weston_compositor_repick(struct weston_compositor *compositor)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400585{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500586 struct weston_input_device *device;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400587 uint32_t time;
588
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500589 if (!compositor->focus)
590 return;
591
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500592 time = weston_compositor_get_time();
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500593 wl_list_for_each(device, &compositor->input_device_list, link)
594 weston_device_repick(&device->input_device, time);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400595}
596
597static void
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500598weston_surface_unmap(struct weston_surface *surface)
599{
600 weston_surface_damage_below(surface);
601 weston_surface_flush_damage(surface);
602 surface->output = NULL;
603 wl_list_remove(&surface->link);
604 weston_compositor_repick(surface->compositor);
605 weston_compositor_schedule_repaint(surface->compositor);
606}
607
608static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400609destroy_surface(struct wl_resource *resource)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500610{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500611 struct weston_surface *surface =
612 container_of(resource,
613 struct weston_surface, surface.resource);
614 struct weston_compositor *compositor = surface->compositor;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400615
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500616 if (surface->output)
617 weston_surface_unmap(surface);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400618
Kristian Høgsberg12bbf812012-02-17 12:15:27 -0500619 if (surface->texture)
620 glDeleteTextures(1, &surface->texture);
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200621
Benjamin Franzke06286262011-05-06 19:12:33 +0200622 if (surface->buffer)
623 wl_list_remove(&surface->buffer_destroy_listener.link);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400624
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200625 if (surface->image != EGL_NO_IMAGE_KHR)
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400626 compositor->destroy_image(compositor->display,
627 surface->image);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200628
Benjamin Franzkebab41fb2011-03-07 18:04:59 +0100629 wl_list_remove(&surface->buffer_link);
630
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200631 pixman_region32_fini(&surface->transform.boundingbox);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200632 pixman_region32_fini(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500633 pixman_region32_fini(&surface->opaque);
Kristian Høgsbergdd631c12012-02-23 16:20:38 -0500634 if (!region_is_undefined(&surface->input))
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500635 pixman_region32_fini(&surface->input);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200636
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400637 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500638}
639
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100640static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500641weston_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface)
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100642{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500643 struct weston_surface *es = (struct weston_surface *) surface;
644 struct weston_compositor *ec = es->compositor;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100645 struct wl_list *surfaces_attached_to;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100646
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500647 if (!es->texture) {
648 glGenTextures(1, &es->texture);
649 glBindTexture(GL_TEXTURE_2D, es->texture);
650 glTexParameteri(GL_TEXTURE_2D,
651 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
652 glTexParameteri(GL_TEXTURE_2D,
653 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
654 es->shader = &ec->texture_shader;
655 } else {
656 glBindTexture(GL_TEXTURE_2D, es->texture);
657 }
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100658
659 if (wl_buffer_is_shm(buffer)) {
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200660 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100661 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200662 es->pitch, buffer->height, 0,
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100663 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
664 wl_shm_buffer_get_data(buffer));
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400665
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100666 surfaces_attached_to = buffer->user_data;
667
Kristian Høgsbergfac11d22011-05-02 13:35:17 -0400668 wl_list_remove(&es->buffer_link);
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100669 wl_list_insert(surfaces_attached_to, &es->buffer_link);
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100670 } else {
Benjamin Franzkefb4b5a22011-06-21 10:44:37 +0200671 if (es->image != EGL_NO_IMAGE_KHR)
672 ec->destroy_image(ec->display, es->image);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400673 es->image = ec->create_image(ec->display, NULL,
674 EGL_WAYLAND_BUFFER_WL,
675 buffer, NULL);
676
677 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400678
Pekka Paalanen60921e52012-01-25 15:55:43 +0200679 es->pitch = es->geometry.width;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100680 }
681}
682
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400683static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500684texture_region(struct weston_surface *es, pixman_region32_t *region)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500685{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500686 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500687 GLfloat *v, inv_width, inv_height;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200688 GLfloat sx, sy;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500689 pixman_box32_t *rectangles;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400690 unsigned int *p;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500691 int i, n;
692
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400693 rectangles = pixman_region32_rectangles(region, &n);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500694 v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
695 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200696 inv_width = 1.0 / es->pitch;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200697 inv_height = 1.0 / es->geometry.height;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400698
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500699 for (i = 0; i < n; i++, v += 16, p += 6) {
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200700 surface_from_global_float(es, rectangles[i].x1,
701 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500702 v[ 0] = rectangles[i].x1;
703 v[ 1] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200704 v[ 2] = sx * inv_width;
705 v[ 3] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500706
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200707 surface_from_global_float(es, rectangles[i].x1,
708 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500709 v[ 4] = rectangles[i].x1;
710 v[ 5] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200711 v[ 6] = sx * inv_width;
712 v[ 7] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500713
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200714 surface_from_global_float(es, rectangles[i].x2,
715 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500716 v[ 8] = rectangles[i].x2;
717 v[ 9] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200718 v[10] = sx * inv_width;
719 v[11] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500720
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200721 surface_from_global_float(es, rectangles[i].x2,
722 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500723 v[12] = rectangles[i].x2;
724 v[13] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200725 v[14] = sx * inv_width;
726 v[15] = sy * inv_height;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500727
728 p[0] = i * 4 + 0;
729 p[1] = i * 4 + 1;
730 p[2] = i * 4 + 2;
731 p[3] = i * 4 + 2;
732 p[4] = i * 4 + 1;
733 p[5] = i * 4 + 3;
734 }
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500735
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400736 return n;
737}
738
Kristian Høgsberg68c479a2012-01-25 23:32:28 -0500739WL_EXPORT void
Kristian Høgsberga0d6dc42012-01-25 22:02:00 -0500740weston_surface_draw(struct weston_surface *es, struct weston_output *output)
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400741{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500742 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400743 GLfloat *v;
744 pixman_region32_t repaint;
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400745 GLint filter;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400746 int n;
747
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200748 pixman_region32_init(&repaint);
749 pixman_region32_intersect(&repaint, &es->transform.boundingbox,
750 &output->region);
Kristian Høgsberga0d6dc42012-01-25 22:02:00 -0500751 pixman_region32_intersect(&repaint, &repaint, &es->damage);
752
Pekka Paalanenc7b45f62012-02-06 12:16:07 +0200753 /* Clear damage, assume outputs do not overlap. */
754 pixman_region32_subtract(&es->damage, &es->damage, &output->region);
755
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400756 if (!pixman_region32_not_empty(&repaint))
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200757 goto out;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400758
Kristian Høgsberg101cb652012-02-17 10:45:16 -0500759 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
760 glEnable(GL_BLEND);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400761
Kristian Høgsberg07632622012-01-25 23:02:06 -0500762 if (ec->current_shader != es->shader) {
763 glUseProgram(es->shader->program);
Kristian Høgsberg07632622012-01-25 23:02:06 -0500764 ec->current_shader = es->shader;
765 }
766
Kristian Høgsberg0452abc2012-01-31 15:38:36 -0500767 glUniformMatrix4fv(es->shader->proj_uniform,
768 1, GL_FALSE, output->matrix.d);
Pekka Paalanenf55f5442012-02-02 16:49:05 +0200769 glUniform1i(es->shader->tex_uniform, 0);
770 glUniform4fv(es->shader->color_uniform, 1, es->color);
771 glUniform1f(es->shader->alpha_uniform, es->alpha / 255.0);
772 glUniform1f(es->shader->texwidth_uniform,
773 (GLfloat)es->geometry.width / es->pitch);
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200774
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200775 if (es->transform.enabled)
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400776 filter = GL_LINEAR;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200777 else
Pekka Paalanenc61eca62012-01-06 14:10:06 +0200778 filter = GL_NEAREST;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200779
780 n = texture_region(es, &repaint);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400781
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500782 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400783 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
784 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
785
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500786 v = ec->vertices.data;
787 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
788 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400789 glEnableVertexAttribArray(0);
790 glEnableVertexAttribArray(1);
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200791
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500792 glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
793
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200794 glDisableVertexAttribArray(1);
795 glDisableVertexAttribArray(0);
796
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500797 ec->vertices.size = 0;
798 ec->indices.size = 0;
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200799
800out:
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500801 pixman_region32_fini(&repaint);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500802}
803
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500804WL_EXPORT struct wl_list *
805weston_compositor_top(struct weston_compositor *compositor)
806{
807 struct weston_input_device *input_device;
808 struct wl_list *list;
809
810 input_device = (struct weston_input_device *) compositor->input_device;
811
812 /* Insert below pointer */
813 list = &compositor->surface_list;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500814 if (compositor->fade.surface &&
815 list->next == &compositor->fade.surface->link)
816 list = list->next;
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500817 if (list->next == &input_device->sprite->link)
818 list = list->next;
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +0200819 if (input_device->drag_surface &&
820 list->next == &input_device->drag_surface->link)
821 list = list->next;
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500822
823 return list;
824}
825
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500826static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500827weston_surface_raise(struct weston_surface *surface)
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400828{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500829 struct weston_compositor *compositor = surface->compositor;
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500830 struct wl_list *list = weston_compositor_top(compositor);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400831
832 wl_list_remove(&surface->link);
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500833 wl_list_insert(list, &surface->link);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500834 weston_compositor_repick(compositor);
835 weston_surface_damage(surface);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400836}
837
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400838WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500839weston_compositor_damage_all(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400840{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500841 struct weston_output *output;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400842
843 wl_list_for_each(output, &compositor->output_list, link)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500844 weston_output_damage(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400845}
846
Kristian Høgsberg9f404b72012-01-26 00:11:01 -0500847WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500848weston_buffer_post_release(struct wl_buffer *buffer)
Benjamin Franzke06286262011-05-06 19:12:33 +0200849{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400850 if (--buffer->busy_count > 0)
Benjamin Franzke06286262011-05-06 19:12:33 +0200851 return;
Benjamin Franzke06286262011-05-06 19:12:33 +0200852
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400853 assert(buffer->resource.client != NULL);
Kristian Høgsbergeccef6a2011-11-17 16:46:19 -0500854 wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
Benjamin Franzke06286262011-05-06 19:12:33 +0200855}
856
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400857WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500858weston_output_damage(struct weston_output *output)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400859{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500860 struct weston_compositor *compositor = output->compositor;
861 struct weston_surface *es;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400862
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500863 if (wl_list_empty(&compositor->surface_list))
864 return;
865
866 es = container_of(compositor->surface_list.next,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500867 struct weston_surface, link);
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500868 pixman_region32_union(&es->damage, &es->damage, &output->region);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500869 weston_compositor_schedule_repaint(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400870}
871
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400872static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500873fade_frame(struct weston_animation *animation,
874 struct weston_output *output, uint32_t msecs)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400875{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500876 struct weston_compositor *compositor =
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400877 container_of(animation,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500878 struct weston_compositor, fade.animation);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500879 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400880
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500881 surface = compositor->fade.surface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500882 weston_spring_update(&compositor->fade.spring, msecs);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500883 weston_surface_set_color(surface, 0.0, 0.0, 0.0,
884 compositor->fade.spring.current);
885 weston_surface_damage(surface);
886
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500887 if (weston_spring_done(&compositor->fade.spring)) {
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400888 compositor->fade.spring.current =
889 compositor->fade.spring.target;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400890 wl_list_remove(&animation->link);
891 wl_list_init(&animation->link);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200892
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500893 if (compositor->fade.spring.current < 0.001) {
894 destroy_surface(&surface->surface.resource);
895 compositor->fade.surface = NULL;
896 } else if (compositor->fade.spring.current > 0.999) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500897 compositor->state = WESTON_COMPOSITOR_SLEEPING;
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200898 compositor->shell->lock(compositor->shell);
899 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400900 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400901}
902
903static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500904weston_output_set_cursor(struct weston_output *output,
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500905 struct wl_input_device *dev)
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200906{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500907 struct weston_input_device *device =
908 (struct weston_input_device *) dev;
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200909 pixman_region32_t cursor_region;
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500910 int prior_was_hardware;
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200911
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -0500912 if (device->sprite == NULL)
913 return;
914
Pekka Paalanen3bfcd4d2012-01-26 11:31:01 +0200915 pixman_region32_init(&cursor_region);
916 pixman_region32_intersect(&cursor_region,
917 &device->sprite->transform.boundingbox,
918 &output->region);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200919
920 if (!pixman_region32_not_empty(&cursor_region)) {
Ander Conselvan de Oliveira02924bc2011-10-24 16:30:15 +0300921 output->set_hardware_cursor(output, NULL);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200922 goto out;
923 }
924
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500925 prior_was_hardware = device->hw_cursor;
926 if (device->sprite->overlapped ||
927 output->set_hardware_cursor(output, device) < 0) {
Matt Roper11568a72011-08-29 15:59:37 -0700928 if (prior_was_hardware) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500929 weston_surface_damage(device->sprite);
Matt Roper11568a72011-08-29 15:59:37 -0700930 output->set_hardware_cursor(output, NULL);
931 }
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500932 device->hw_cursor = 0;
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500933 } else {
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500934 if (!prior_was_hardware)
935 weston_surface_damage_below(device->sprite);
936 pixman_region32_fini(&device->sprite->damage);
937 pixman_region32_init(&device->sprite->damage);
938 device->hw_cursor = 1;
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500939 }
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200940
941out:
942 pixman_region32_fini(&cursor_region);
943}
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400944
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500945struct weston_frame_callback {
946 struct wl_resource resource;
947 struct wl_list link;
948};
949
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400950static void
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500951weston_output_repaint(struct weston_output *output, int msecs)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400952{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500953 struct weston_compositor *ec = output->compositor;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500954 struct weston_surface *es;
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500955 struct weston_animation *animation, *next;
956 struct weston_frame_callback *cb, *cnext;
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500957 pixman_region32_t opaque, new_damage, total_damage,
958 overlap, surface_overlap;
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500959 int32_t width, height;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500960
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +0200961 weston_compositor_update_drag_surfaces(ec);
962
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500963 width = output->current->width +
964 output->border.left + output->border.right;
965 height = output->current->height +
966 output->border.top + output->border.bottom;
967 glViewport(0, 0, width, height);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -0500968
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500969 pixman_region32_init(&new_damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400970 pixman_region32_init(&opaque);
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500971 pixman_region32_init(&overlap);
972
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400973 wl_list_for_each(es, &ec->surface_list, link) {
Pekka Paalanenb45ac5e2012-02-09 15:58:44 +0200974 /* Update surface transform now to avoid calling it ever
975 * again from the repaint sub-functions. */
Pekka Paalanen15d60ef2012-01-27 14:38:33 +0200976 weston_surface_update_transform(es);
977
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500978 pixman_region32_init(&surface_overlap);
Pekka Paalanen15d60ef2012-01-27 14:38:33 +0200979 pixman_region32_intersect(&surface_overlap, &overlap,
980 &es->transform.boundingbox);
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -0500981 es->overlapped = pixman_region32_not_empty(&surface_overlap);
982 pixman_region32_fini(&surface_overlap);
Pekka Paalanen15d60ef2012-01-27 14:38:33 +0200983 pixman_region32_union(&overlap, &overlap,
984 &es->transform.boundingbox);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400985 }
986
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500987 weston_output_set_cursor(output, ec->input_device);
988
989 wl_list_for_each(es, &ec->surface_list, link) {
990 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
991 pixman_region32_union(&new_damage, &new_damage, &es->damage);
Pekka Paalanen730d87e2012-02-09 16:39:38 +0200992 pixman_region32_union(&opaque, &opaque, &es->transform.opaque);
Kristian Høgsberga82c4862012-01-26 01:03:58 -0500993 }
994
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400995 pixman_region32_init(&total_damage);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500996 pixman_region32_union(&total_damage, &new_damage,
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400997 &output->previous_damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400998 pixman_region32_intersect(&output->previous_damage,
999 &new_damage, &output->region);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001000
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -04001001 pixman_region32_fini(&opaque);
Kristian Høgsberg765bcdf2012-01-25 22:20:30 -05001002 pixman_region32_fini(&overlap);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -04001003 pixman_region32_fini(&new_damage);
1004
Kristian Høgsbergac587412012-01-25 21:48:26 -05001005 wl_list_for_each(es, &ec->surface_list, link) {
1006 pixman_region32_copy(&es->damage, &total_damage);
1007 pixman_region32_subtract(&total_damage,
Pekka Paalanen730d87e2012-02-09 16:39:38 +02001008 &total_damage, &es->transform.opaque);
Kristian Høgsbergac587412012-01-25 21:48:26 -05001009 }
1010
Kristian Høgsberg68c479a2012-01-25 23:32:28 -05001011 output->repaint(output);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001012
Pekka Paalanencc9102e2012-01-02 15:42:44 +02001013 pixman_region32_fini(&total_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001014
Kristian Høgsbergef044142011-06-21 15:02:12 -04001015 output->repaint_needed = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001016
Kristian Høgsberg33418202011-08-16 23:01:28 -04001017 wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) {
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001018 wl_resource_post_event(&cb->resource, WL_CALLBACK_DONE, msecs);
1019 wl_resource_destroy(&cb->resource, 0);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001020 }
1021
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001022 wl_list_for_each_safe(animation, next, &ec->animation_list, link)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001023 animation->frame(animation, output, msecs);
1024}
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001025
Kristian Høgsbergef044142011-06-21 15:02:12 -04001026static void
1027idle_repaint(void *data)
1028{
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05001029 struct weston_output *output = data;
1030
1031 /* An idle repaint may have been cancelled by vt switching away. */
1032 if (output->repaint_needed)
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001033 weston_output_repaint(output, weston_compositor_get_time());
Kristian Høgsberg2200d702012-01-26 08:47:04 -05001034 else
1035 output->repaint_scheduled = 0;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001036}
1037
1038WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001039weston_output_finish_frame(struct weston_output *output, int msecs)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001040{
Kristian Høgsbergef044142011-06-21 15:02:12 -04001041 if (output->repaint_needed)
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001042 weston_output_repaint(output, msecs);
Ander Conselvan de Oliveira22e22a52011-10-24 16:30:14 +03001043 else
1044 output->repaint_scheduled = 0;
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001045}
1046
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001047WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001048weston_compositor_schedule_repaint(struct weston_compositor *compositor)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001049{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001050 struct weston_output *output;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001051 struct wl_event_loop *loop;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001052
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001053 if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001054 return;
1055
Kristian Høgsbergef044142011-06-21 15:02:12 -04001056 loop = wl_display_get_event_loop(compositor->wl_display);
1057 wl_list_for_each(output, &compositor->output_list, link) {
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001058 output->repaint_needed = 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001059 if (output->repaint_scheduled)
1060 continue;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001061
Kristian Høgsbergef044142011-06-21 15:02:12 -04001062 wl_event_loop_add_idle(loop, idle_repaint, output);
1063 output->repaint_scheduled = 1;
1064 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001065}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -05001066
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001067WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001068weston_compositor_fade(struct weston_compositor *compositor, float tint)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001069{
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001070 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001071 int done;
1072
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001073 done = weston_spring_done(&compositor->fade.spring);
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001074 compositor->fade.spring.target = tint;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001075 if (weston_spring_done(&compositor->fade.spring))
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001076 return;
1077
1078 if (done)
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001079 compositor->fade.spring.timestamp =
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001080 weston_compositor_get_time();
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001081
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001082 if (compositor->fade.surface == NULL) {
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001083 surface = weston_surface_create(compositor);
1084 weston_surface_configure(surface, 0, 0, 8192, 8192);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001085 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0);
1086 wl_list_insert(&compositor->surface_list, &surface->link);
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02001087 weston_surface_assign_output(surface);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001088 compositor->fade.surface = surface;
1089 }
1090
1091 weston_surface_damage(compositor->fade.surface);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001092 if (wl_list_empty(&compositor->fade.animation.link))
1093 wl_list_insert(compositor->animation_list.prev,
1094 &compositor->fade.animation.link);
1095}
1096
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001097static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001098surface_destroy(struct wl_client *client, struct wl_resource *resource)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001099{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001100 wl_resource_destroy(resource, weston_compositor_get_time());
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001101}
1102
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001103WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001104weston_surface_assign_output(struct weston_surface *es)
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001105{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001106 struct weston_compositor *ec = es->compositor;
1107 struct weston_output *output, *new_output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001108 pixman_region32_t region;
1109 uint32_t max, area;
1110 pixman_box32_t *e;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001111
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001112 weston_surface_update_transform(es);
1113
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001114 new_output = NULL;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001115 max = 0;
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001116 pixman_region32_init(&region);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001117 wl_list_for_each(output, &ec->output_list, link) {
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001118 pixman_region32_intersect(&region, &es->transform.boundingbox,
1119 &output->region);
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001120
1121 e = pixman_region32_extents(&region);
1122 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1123
1124 if (area >= max) {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001125 new_output = output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001126 max = area;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001127 }
1128 }
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001129 pixman_region32_fini(&region);
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001130
1131 es->output = new_output;
1132 if (!wl_list_empty(&es->frame_callback_list)) {
1133 wl_list_insert_list(new_output->frame_callback_list.prev,
1134 &es->frame_callback_list);
1135 wl_list_init(&es->frame_callback_list);
1136 }
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001137}
1138
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001139static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001140surface_attach(struct wl_client *client,
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001141 struct wl_resource *resource,
Pekka Paalanena4f80f32012-01-31 12:04:54 +02001142 struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001143{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001144 struct weston_surface *es = resource->data;
1145 struct weston_shell *shell = es->compositor->shell;
Kristian Høgsbergd0e2ef72012-02-19 22:15:21 -05001146 struct wl_buffer *buffer;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001147
Ander Conselvan de Oliveirab63e3e02012-02-15 17:02:53 +02001148 if (!buffer_resource && !es->output)
1149 return;
1150
Kristian Høgsberg24596942011-10-24 17:51:02 -04001151 if (es->buffer) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001152 weston_buffer_post_release(es->buffer);
Kristian Høgsberg24596942011-10-24 17:51:02 -04001153 wl_list_remove(&es->buffer_destroy_listener.link);
1154 }
Benjamin Franzke06286262011-05-06 19:12:33 +02001155
Kristian Høgsbergd1e86252012-01-30 09:10:14 -05001156 if (!buffer_resource && es->output) {
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -05001157 weston_surface_unmap(es);
Ander Conselvan de Oliveirab63e3e02012-02-15 17:02:53 +02001158 es->buffer = NULL;
Kristian Høgsbergd1e86252012-01-30 09:10:14 -05001159 return;
1160 }
1161
1162 buffer = buffer_resource->data;
Kristian Høgsberg24596942011-10-24 17:51:02 -04001163 buffer->busy_count++;
Benjamin Franzke06286262011-05-06 19:12:33 +02001164 es->buffer = buffer;
Benjamin Franzke06286262011-05-06 19:12:33 +02001165 wl_list_insert(es->buffer->resource.destroy_listener_list.prev,
1166 &es->buffer_destroy_listener.link);
1167
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001168 if (es->geometry.width != buffer->width ||
1169 es->geometry.height != buffer->height) {
1170 undef_region(&es->input);
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05001171 pixman_region32_fini(&es->opaque);
1172 pixman_region32_init(&es->opaque);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001173 }
1174
Kristian Høgsbergd0e2ef72012-02-19 22:15:21 -05001175 if (es->output == NULL) {
Ander Conselvan de Oliveirae9e05152012-02-15 17:02:56 +02001176 shell->map(shell, es, buffer->width, buffer->height, sx, sy);
Pekka Paalanena4f80f32012-01-31 12:04:54 +02001177 } else if (sx != 0 || sy != 0 ||
Pekka Paalanen60921e52012-01-25 15:55:43 +02001178 es->geometry.width != buffer->width ||
1179 es->geometry.height != buffer->height) {
Pekka Paalanenddae03c2012-02-06 14:54:20 +02001180 GLfloat from_x, from_y;
1181 GLfloat to_x, to_y;
Pekka Paalanena4f80f32012-01-31 12:04:54 +02001182
Pekka Paalanenddae03c2012-02-06 14:54:20 +02001183 surface_to_global_float(es, 0, 0, &from_x, &from_y);
1184 surface_to_global_float(es, sx, sy, &to_x, &to_y);
Pekka Paalanena4f80f32012-01-31 12:04:54 +02001185 shell->configure(shell, es,
1186 es->geometry.x + to_x - from_x,
1187 es->geometry.y + to_y - from_y,
Kristian Høgsberg32e24cc2011-11-09 12:07:35 -05001188 buffer->width, buffer->height);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001189 }
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001190
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001191 weston_buffer_attach(buffer, &es->surface);
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001192}
1193
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001194static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001195surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001196 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001197 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -05001198{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001199 struct weston_surface *es = resource->data;
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -04001200
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001201 weston_surface_damage_rectangle(es, x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001202}
1203
Kristian Høgsberg33418202011-08-16 23:01:28 -04001204static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001205destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001206{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001207 struct weston_frame_callback *cb = resource->data;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001208
1209 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02001210 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001211}
1212
1213static void
1214surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001215 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001216{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001217 struct weston_frame_callback *cb;
1218 struct weston_surface *es = resource->data;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001219
1220 cb = malloc(sizeof *cb);
1221 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001222 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001223 return;
1224 }
1225
1226 cb->resource.object.interface = &wl_callback_interface;
1227 cb->resource.object.id = callback;
1228 cb->resource.destroy = destroy_frame_callback;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001229 cb->resource.client = client;
1230 cb->resource.data = cb;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001231
1232 wl_client_add_resource(client, &cb->resource);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001233
1234 if (es->output) {
1235 wl_list_insert(es->output->frame_callback_list.prev,
1236 &cb->link);
1237 } else {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001238 wl_list_insert(es->frame_callback_list.prev, &cb->link);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001239 }
Kristian Høgsberg33418202011-08-16 23:01:28 -04001240}
1241
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001242static void
1243surface_set_opaque_region(struct wl_client *client,
1244 struct wl_resource *resource,
1245 struct wl_resource *region_resource)
1246{
1247 struct weston_surface *surface = resource->data;
1248 struct weston_region *region;
1249
1250 pixman_region32_fini(&surface->opaque);
1251
1252 if (region_resource) {
1253 region = region_resource->data;
1254 pixman_region32_init_rect(&surface->opaque, 0, 0,
1255 surface->geometry.width,
1256 surface->geometry.height);
1257 pixman_region32_intersect(&surface->opaque,
1258 &surface->opaque, &region->region);
1259 } else {
1260 pixman_region32_init(&surface->opaque);
1261 }
1262
1263 surface->geometry.dirty = 1;
1264}
1265
1266static void
1267surface_set_input_region(struct wl_client *client,
1268 struct wl_resource *resource,
1269 struct wl_resource *region_resource)
1270{
1271 struct weston_surface *surface = resource->data;
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05001272 struct weston_region *region;
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001273
1274 if (region_resource) {
1275 region = region_resource->data;
1276 pixman_region32_init_rect(&surface->input, 0, 0,
1277 surface->geometry.width,
1278 surface->geometry.height);
1279 pixman_region32_intersect(&surface->input,
1280 &surface->input, &region->region);
1281 } else {
1282 pixman_region32_init_rect(&surface->input, 0, 0,
1283 surface->geometry.width,
1284 surface->geometry.height);
1285 }
1286
1287 weston_compositor_repick(surface->compositor);
1288}
1289
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001290const static struct wl_surface_interface surface_interface = {
1291 surface_destroy,
1292 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04001293 surface_damage,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001294 surface_frame,
1295 surface_set_opaque_region,
1296 surface_set_input_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001297};
1298
1299static void
1300compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001301 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001302{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001303 struct weston_compositor *ec = resource->data;
1304 struct weston_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001305
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001306 surface = weston_surface_create(ec);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001307 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001308 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001309 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001310 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001311
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001312 surface->surface.resource.destroy = destroy_surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001313
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001314 surface->surface.resource.object.id = id;
1315 surface->surface.resource.object.interface = &wl_surface_interface;
1316 surface->surface.resource.object.implementation =
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001317 (void (**)(void)) &surface_interface;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001318 surface->surface.resource.data = surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001319
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001320 wl_client_add_resource(client, &surface->surface.resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001321}
1322
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001323static void
1324destroy_region(struct wl_resource *resource)
1325{
1326 struct weston_region *region =
1327 container_of(resource, struct weston_region, resource);
1328
1329 pixman_region32_fini(&region->region);
1330 free(region);
1331}
1332
1333static void
1334region_destroy(struct wl_client *client, struct wl_resource *resource)
1335{
1336 wl_resource_destroy(resource, weston_compositor_get_time());
1337}
1338
1339static void
1340region_add(struct wl_client *client, struct wl_resource *resource,
1341 int32_t x, int32_t y, int32_t width, int32_t height)
1342{
1343 struct weston_region *region = resource->data;
1344
1345 pixman_region32_union_rect(&region->region, &region->region,
1346 x, y, width, height);
1347}
1348
1349static void
1350region_subtract(struct wl_client *client, struct wl_resource *resource,
1351 int32_t x, int32_t y, int32_t width, int32_t height)
1352{
1353 struct weston_region *region = resource->data;
1354 pixman_region32_t rect;
1355
1356 pixman_region32_init_rect(&rect, x, y, width, height);
1357 pixman_region32_subtract(&region->region, &region->region, &rect);
1358 pixman_region32_fini(&rect);
1359}
1360
1361static const struct wl_region_interface region_interface = {
1362 region_destroy,
1363 region_add,
1364 region_subtract
1365};
1366
1367static void
1368compositor_create_region(struct wl_client *client,
1369 struct wl_resource *resource, uint32_t id)
1370{
1371 struct weston_region *region;
1372
1373 region = malloc(sizeof *region);
1374 if (region == NULL) {
1375 wl_resource_post_no_memory(resource);
1376 return;
1377 }
1378
1379 region->resource.destroy = destroy_region;
1380
1381 region->resource.object.id = id;
1382 region->resource.object.interface = &wl_region_interface;
1383 region->resource.object.implementation =
1384 (void (**)(void)) &region_interface;
1385 region->resource.data = region;
1386
1387 pixman_region32_init(&region->region);
1388
1389 wl_client_add_resource(client, &region->resource);
1390}
1391
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001392const static struct wl_compositor_interface compositor_interface = {
1393 compositor_create_surface,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001394 compositor_create_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001395};
1396
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001397WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001398weston_compositor_wake(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001399{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001400 compositor->state = WESTON_COMPOSITOR_ACTIVE;
1401 weston_compositor_fade(compositor, 0.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001402
1403 wl_event_source_timer_update(compositor->idle_source,
Pekka Paalanen7296e792011-12-07 16:22:00 +02001404 compositor->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001405}
1406
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001407WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001408weston_compositor_activity(struct weston_compositor *compositor)
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001409{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001410 if (compositor->state == WESTON_COMPOSITOR_ACTIVE) {
1411 weston_compositor_wake(compositor);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001412 } else {
1413 compositor->shell->unlock(compositor->shell);
1414 }
1415}
1416
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001417static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001418weston_compositor_idle_inhibit(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001419{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001420 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001421 compositor->idle_inhibit++;
1422}
1423
1424static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001425weston_compositor_idle_release(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001426{
1427 compositor->idle_inhibit--;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001428 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001429}
1430
1431static int
1432idle_handler(void *data)
1433{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001434 struct weston_compositor *compositor = data;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001435
1436 if (compositor->idle_inhibit)
1437 return 1;
1438
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001439 weston_compositor_fade(compositor, 1.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001440
1441 return 1;
1442}
1443
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001444static void
1445weston_input_update_drag_surface(struct wl_input_device *input_device,
1446 int dx, int dy);
1447
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001448WL_EXPORT void
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001449notify_motion(struct wl_input_device *device, uint32_t time, int x, int y)
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001450{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001451 struct weston_output *output;
Scott Moreau447013d2012-02-18 05:05:29 -07001452 const struct wl_pointer_grab_interface *interface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001453 struct weston_input_device *wd = (struct weston_input_device *) device;
1454 struct weston_compositor *ec = wd->compositor;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001455 int x_valid = 0, y_valid = 0;
1456 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 -05001457
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001458 weston_compositor_activity(ec);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001459
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001460 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001461 if (output->x <= x && x <= output->x + output->current->width)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001462 x_valid = 1;
1463
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001464 if (output->y <= y && y <= output->y + output->current->height)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001465 y_valid = 1;
1466
1467 /* FIXME: calculate this only on output addition/deletion */
1468 if (output->x < min_x)
1469 min_x = output->x;
1470 if (output->y < min_y)
1471 min_y = output->y;
1472
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001473 if (output->x + output->current->width > max_x)
1474 max_x = output->x + output->current->width;
1475 if (output->y + output->current->height > max_y)
1476 max_y = output->y + output->current->height;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001477 }
1478
1479 if (!x_valid) {
1480 if (x < min_x)
1481 x = min_x;
1482 else if (x >= max_x)
1483 x = max_x;
1484 }
1485 if (!y_valid) {
1486 if (y < min_y)
1487 y = min_y;
1488 else if (y >= max_y)
1489 y = max_y;
1490 }
Ray Strode90e701d2008-12-18 23:05:43 -05001491
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001492 weston_input_update_drag_surface(device,
1493 x - device->x, y - device->y);
1494
Kristian Høgsberge3ef3e52008-12-21 19:30:01 -05001495 device->x = x;
1496 device->y = y;
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -05001497
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001498 weston_device_repick(device, time);
Scott Moreau447013d2012-02-18 05:05:29 -07001499 interface = device->pointer_grab->interface;
1500 interface->motion(device->pointer_grab, time,
1501 device->pointer_grab->x, device->pointer_grab->y);
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001502
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001503 if (wd->sprite) {
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +02001504 weston_surface_set_position(wd->sprite,
1505 device->x - wd->hotspot_x,
1506 device->y - wd->hotspot_y);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001507
Pekka Paalanenf8c6aae2012-02-13 11:01:59 +02001508 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001509 }
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001510}
1511
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001512WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001513weston_surface_activate(struct weston_surface *surface,
1514 struct weston_input_device *device, uint32_t time)
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001515{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001516 weston_surface_raise(surface);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001517 wl_input_device_set_keyboard_focus(&device->input_device,
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001518 &surface->surface, time);
Kristian Høgsbergdade6492012-01-04 21:47:30 -05001519 wl_data_device_set_keyboard_focus(&device->input_device);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001520}
1521
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001522WL_EXPORT void
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001523notify_button(struct wl_input_device *device,
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001524 uint32_t time, int32_t button, int32_t state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001525{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001526 struct weston_input_device *wd = (struct weston_input_device *) device;
1527 struct weston_compositor *compositor = wd->compositor;
Kristian Høgsbergea081152010-12-07 08:59:51 -05001528
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001529 if (state) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001530 weston_compositor_idle_inhibit(compositor);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001531 if (device->button_count == 0) {
1532 device->grab_button = button;
1533 device->grab_time = time;
1534 device->grab_x = device->x;
1535 device->grab_y = device->y;
1536 }
1537 device->button_count++;
1538 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001539 weston_compositor_idle_release(compositor);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001540 device->button_count--;
1541 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001542
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001543 weston_compositor_run_binding(compositor, wd, time, 0, button, state);
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001544
Scott Moreau447013d2012-02-18 05:05:29 -07001545 device->pointer_grab->interface->button(device->pointer_grab, time, button, state);
Kristian Høgsberg5a5f0072011-12-19 14:54:11 -05001546
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001547}
1548
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001549static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001550update_modifier_state(struct weston_input_device *device,
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001551 uint32_t key, uint32_t state)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001552{
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001553 uint32_t modifier;
Kristian Høgsbergab909ae2001-01-01 22:24:24 -05001554
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001555 switch (key) {
1556 case KEY_LEFTCTRL:
1557 case KEY_RIGHTCTRL:
1558 modifier = MODIFIER_CTRL;
1559 break;
1560
1561 case KEY_LEFTALT:
1562 case KEY_RIGHTALT:
1563 modifier = MODIFIER_ALT;
1564 break;
1565
Kristian Høgsberg5b75f1b2010-08-04 23:21:41 -04001566 case KEY_LEFTMETA:
1567 case KEY_RIGHTMETA:
1568 modifier = MODIFIER_SUPER;
1569 break;
1570
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001571 default:
1572 modifier = 0;
1573 break;
1574 }
1575
1576 if (state)
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001577 device->modifier_state |= modifier;
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001578 else
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001579 device->modifier_state &= ~modifier;
1580}
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001581
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001582WL_EXPORT void
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001583notify_key(struct wl_input_device *device,
1584 uint32_t time, uint32_t key, uint32_t state)
1585{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001586 struct weston_input_device *wd = (struct weston_input_device *) device;
1587 struct weston_compositor *compositor = wd->compositor;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001588 uint32_t *k, *end;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001589
Scott Moreauec286eb2012-02-18 05:05:30 -07001590 if (state) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001591 weston_compositor_idle_inhibit(compositor);
Scott Moreauec286eb2012-02-18 05:05:30 -07001592 device->grab_key = key;
1593 device->grab_time = time;
1594 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001595 weston_compositor_idle_release(compositor);
Scott Moreauec286eb2012-02-18 05:05:30 -07001596 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001597
Kristian Høgsbergafa264c2012-02-19 18:50:55 -05001598 if (device->keyboard_grab == &device->default_keyboard_grab)
1599 weston_compositor_run_binding(compositor, wd,
1600 time, key, 0, state);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001601
1602 update_modifier_state(wd, key, state);
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001603 end = device->keys.data + device->keys.size;
1604 for (k = device->keys.data; k < end; k++) {
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001605 if (*k == key)
1606 *k = *--end;
1607 }
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001608 device->keys.size = (void *) end - device->keys.data;
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001609 if (state) {
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001610 k = wl_array_add(&device->keys, sizeof *k);
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001611 *k = key;
1612 }
Ray Strodee96dcb82008-12-20 02:00:49 -05001613
Scott Moreauec286eb2012-02-18 05:05:30 -07001614 device->keyboard_grab->interface->key(device->keyboard_grab,
1615 time, key, state);
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001616}
1617
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001618WL_EXPORT void
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001619notify_pointer_focus(struct wl_input_device *device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001620 uint32_t time, struct weston_output *output,
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001621 int32_t x, int32_t y)
1622{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001623 struct weston_input_device *wd = (struct weston_input_device *) device;
1624 struct weston_compositor *compositor = wd->compositor;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001625
1626 if (output) {
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001627 weston_input_update_drag_surface(device, x - device->x,
1628 y - device->y);
1629
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001630 device->x = x;
1631 device->y = y;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001632 compositor->focus = 1;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001633 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001634 } else {
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001635 compositor->focus = 0;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001636 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001637 }
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001638}
1639
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001640WL_EXPORT void
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001641notify_keyboard_focus(struct wl_input_device *device,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001642 uint32_t time, struct weston_output *output,
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001643 struct wl_array *keys)
1644{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001645 struct weston_input_device *wd =
1646 (struct weston_input_device *) device;
1647 struct weston_compositor *compositor = wd->compositor;
1648 struct weston_surface *es;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001649 uint32_t *k, *end;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001650
1651 if (!wl_list_empty(&compositor->surface_list))
1652 es = container_of(compositor->surface_list.next,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001653 struct weston_surface, link);
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001654 else
1655 es = NULL;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001656
1657 if (output) {
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001658 wl_array_copy(&wd->input_device.keys, keys);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001659 wd->modifier_state = 0;
1660 end = device->keys.data + device->keys.size;
1661 for (k = device->keys.data; k < end; k++) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001662 weston_compositor_idle_inhibit(compositor);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001663 update_modifier_state(wd, *k, 1);
1664 }
1665
Kristian Høgsbergf59da392011-09-06 13:44:56 -04001666 if (es && es->surface.resource.client)
Benjamin Franzkeb7c00a42011-06-23 23:30:30 +02001667 wl_input_device_set_keyboard_focus(&wd->input_device,
1668 &es->surface, time);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001669 } else {
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001670 end = device->keys.data + device->keys.size;
1671 for (k = device->keys.data; k < end; k++)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001672 weston_compositor_idle_release(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001673
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001674 wd->modifier_state = 0;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001675 wl_input_device_set_keyboard_focus(&wd->input_device,
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001676 NULL, time);
1677 }
1678}
1679
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001680/* TODO: share this function with wayland-server.c */
1681static struct wl_resource *
1682find_resource_for_surface(struct wl_list *list, struct wl_surface *surface)
1683{
1684 struct wl_resource *r;
1685
1686 if (!surface)
1687 return NULL;
1688
1689 wl_list_for_each(r, list, link) {
1690 if (r->client == surface->resource.client)
1691 return r;
1692 }
1693
1694 return NULL;
1695}
1696
1697static void
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001698lose_touch_focus_resource(struct wl_listener *listener,
1699 struct wl_resource *resource, uint32_t time)
1700{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001701 struct weston_input_device *device =
1702 container_of(listener, struct weston_input_device,
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001703 touch_focus_resource_listener);
1704
1705 device->touch_focus_resource = NULL;
1706}
1707
1708static void
1709lose_touch_focus(struct wl_listener *listener,
1710 struct wl_resource *resource, uint32_t time)
1711{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001712 struct weston_input_device *device =
1713 container_of(listener, struct weston_input_device,
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001714 touch_focus_listener);
1715
1716 device->touch_focus = NULL;
1717}
1718
1719static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001720touch_set_focus(struct weston_input_device *device,
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001721 struct wl_surface *surface, uint32_t time)
1722{
1723 struct wl_input_device *input_device = &device->input_device;
1724 struct wl_resource *resource;
1725
1726 if (device->touch_focus == surface)
1727 return;
1728
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001729 if (surface) {
1730 resource =
1731 find_resource_for_surface(&input_device->resource_list,
1732 surface);
1733 if (!resource) {
1734 fprintf(stderr, "couldn't find resource\n");
1735 return;
1736 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001737
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001738 device->touch_focus_resource_listener.func =
1739 lose_touch_focus_resource;
1740 wl_list_insert(resource->destroy_listener_list.prev,
1741 &device->touch_focus_resource_listener.link);
1742 device->touch_focus_listener.func = lose_touch_focus;
1743 wl_list_insert(surface->resource.destroy_listener_list.prev,
1744 &device->touch_focus_listener.link);
1745
1746 device->touch_focus = surface;
1747 device->touch_focus_resource = resource;
1748 } else {
1749 if (device->touch_focus)
1750 wl_list_remove(&device->touch_focus_listener.link);
1751 if (device->touch_focus_resource)
1752 wl_list_remove(&device->touch_focus_resource_listener.link);
1753 device->touch_focus = NULL;
1754 device->touch_focus_resource = NULL;
1755 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001756}
1757
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001758/**
1759 * notify_touch - emulates button touches and notifies surfaces accordingly.
1760 *
1761 * It assumes always the correct cycle sequence until it gets here: touch_down
1762 * → touch_update → ... → touch_update → touch_end. The driver is responsible
1763 * for sending along such order.
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001764 *
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001765 */
1766WL_EXPORT void
1767notify_touch(struct wl_input_device *device, uint32_t time, int touch_id,
1768 int x, int y, int touch_type)
1769{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001770 struct weston_input_device *wd = (struct weston_input_device *) device;
1771 struct weston_compositor *ec = wd->compositor;
1772 struct weston_surface *es;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001773 int32_t sx, sy;
1774
1775 switch (touch_type) {
1776 case WL_INPUT_DEVICE_TOUCH_DOWN:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001777 weston_compositor_idle_inhibit(ec);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001778
1779 wd->num_tp++;
1780
1781 /* the first finger down picks the surface, and all further go
1782 * to that surface for the remainder of the touch session i.e.
1783 * until all touch points are up again. */
1784 if (wd->num_tp == 1) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001785 es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001786 touch_set_focus(wd, &es->surface, time);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001787 } else if (wd->touch_focus) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001788 es = (struct weston_surface *) wd->touch_focus;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001789 weston_surface_from_global(es, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001790 }
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001791
1792 if (wd->touch_focus_resource && wd->touch_focus)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001793 wl_resource_post_event(wd->touch_focus_resource,
1794 touch_type, time,
1795 wd->touch_focus,
1796 touch_id, sx, sy);
1797 break;
1798 case WL_INPUT_DEVICE_TOUCH_MOTION:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001799 es = (struct weston_surface *) wd->touch_focus;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001800 if (!es)
1801 break;
1802
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001803 weston_surface_from_global(es, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001804 if (wd->touch_focus_resource)
1805 wl_resource_post_event(wd->touch_focus_resource,
Kristian Høgsberg3543ff42011-12-21 17:25:54 -05001806 touch_type, time,
1807 touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001808 break;
1809 case WL_INPUT_DEVICE_TOUCH_UP:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001810 weston_compositor_idle_release(ec);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001811 wd->num_tp--;
1812
Kristian Høgsberg3543ff42011-12-21 17:25:54 -05001813 if (wd->touch_focus_resource)
1814 wl_resource_post_event(wd->touch_focus_resource,
1815 touch_type, time, touch_id);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001816 if (wd->num_tp == 0)
1817 touch_set_focus(wd, NULL, time);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001818 break;
1819 }
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001820}
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001821
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04001822static void
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001823input_device_attach(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001824 struct wl_resource *resource,
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001825 uint32_t time,
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001826 struct wl_resource *buffer_resource, int32_t x, int32_t y)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001827{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001828 struct weston_input_device *device = resource->data;
1829 struct weston_compositor *compositor = device->compositor;
Kristian Høgsberg57295eb2011-08-29 16:02:57 -04001830 struct wl_buffer *buffer;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001831
1832 if (time < device->input_device.pointer_focus_time)
1833 return;
1834 if (device->input_device.pointer_focus == NULL)
1835 return;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001836 if (device->input_device.pointer_focus->resource.client != client)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001837 return;
1838
Kristian Høgsbergaded1f62012-02-08 16:33:57 -05001839 if (!buffer_resource && device->sprite->output) {
1840 wl_list_remove(&device->sprite->link);
Kristian Høgsbergaded1f62012-02-08 16:33:57 -05001841 device->sprite->output = NULL;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001842 return;
1843 }
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001844
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02001845 if (!device->sprite->output) {
Kristian Høgsberga82c4862012-01-26 01:03:58 -05001846 wl_list_insert(&compositor->surface_list,
1847 &device->sprite->link);
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02001848 weston_surface_assign_output(device->sprite);
1849 }
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001850
1851 buffer = buffer_resource->data;
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001852 device->hotspot_x = x;
1853 device->hotspot_y = y;
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001854 weston_surface_configure(device->sprite,
1855 device->input_device.x - device->hotspot_x,
1856 device->input_device.y - device->hotspot_y,
1857 buffer->width, buffer->height);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001858
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001859 weston_buffer_attach(buffer, &device->sprite->surface);
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001860}
1861
1862const static struct wl_input_device_interface input_device_interface = {
1863 input_device_attach,
1864};
1865
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001866static void unbind_input_device(struct wl_resource *resource)
1867{
1868 wl_list_remove(&resource->link);
1869 free(resource);
1870}
1871
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001872static void
1873bind_input_device(struct wl_client *client,
1874 void *data, uint32_t version, uint32_t id)
1875{
Kristian Høgsberg8e6d7122011-08-29 16:04:39 -04001876 struct wl_input_device *device = data;
1877 struct wl_resource *resource;
1878
1879 resource = wl_client_add_object(client, &wl_input_device_interface,
1880 &input_device_interface, id, data);
1881 wl_list_insert(&device->resource_list, &resource->link);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001882 resource->destroy = unbind_input_device;
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001883}
1884
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001885WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001886weston_input_device_init(struct weston_input_device *device,
1887 struct weston_compositor *ec)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001888{
Kristian Høgsberga8873122011-11-23 10:39:34 -05001889 wl_input_device_init(&device->input_device);
Kristian Høgsberg02ef1c12010-12-06 21:35:19 -05001890
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001891 wl_display_add_global(ec->wl_display, &wl_input_device_interface,
1892 device, bind_input_device);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001893
Kristian Høgsbergaded1f62012-02-08 16:33:57 -05001894 device->sprite = weston_surface_create(ec);
Kristian Høgsberg8244b442011-06-23 15:44:14 -04001895
Kristian Høgsberga8873122011-11-23 10:39:34 -05001896 device->compositor = ec;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04001897 device->hotspot_x = 16;
1898 device->hotspot_y = 16;
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001899 device->modifier_state = 0;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001900 device->num_tp = 0;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001901
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001902 wl_list_insert(ec->input_device_list.prev, &device->link);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001903}
1904
Pekka Paalanen07753fb2012-01-02 15:31:01 +02001905WL_EXPORT void
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05001906weston_input_device_release(struct weston_input_device *device)
Pekka Paalanen07753fb2012-01-02 15:31:01 +02001907{
1908 wl_list_remove(&device->link);
1909 /* The global object is destroyed at wl_display_destroy() time. */
1910
1911 if (device->sprite)
1912 destroy_surface(&device->sprite->surface.resource);
1913
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05001914 wl_input_device_release(&device->input_device);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02001915}
1916
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001917static void
1918weston_input_update_drag_surface(struct wl_input_device *input_device,
1919 int dx, int dy)
1920{
1921 int surface_changed = 0;
1922 struct weston_input_device *device = (struct weston_input_device *)
1923 input_device;
1924
1925 if (!device->drag_surface && !input_device->drag_surface)
1926 return;
1927
1928 if (device->drag_surface && input_device->drag_surface &&
1929 (&device->drag_surface->surface.resource !=
1930 &input_device->drag_surface->resource))
1931 /* between calls to this funcion we got a new drag_surface */
1932 surface_changed = 1;
1933
1934 if (!input_device->drag_surface || surface_changed) {
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001935 device->drag_surface = NULL;
1936 if (!surface_changed)
1937 return;
1938 }
1939
1940 if (!device->drag_surface || surface_changed) {
1941 device->drag_surface = (struct weston_surface *)
1942 input_device->drag_surface;
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001943
1944 weston_surface_set_position(device->drag_surface,
1945 input_device->x, input_device->y);
1946 }
1947
1948 if (device->drag_surface->output == NULL &&
1949 device->drag_surface->buffer) {
1950 wl_list_insert(weston_compositor_top(device->compositor),
1951 &device->drag_surface->link);
Ander Conselvan de Oliveiraa2f11292012-02-23 13:29:26 +02001952 weston_surface_assign_output(device->drag_surface);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001953 }
1954
1955 if (!dx && !dy)
1956 return;
1957
1958 weston_surface_set_position(device->drag_surface,
1959 device->drag_surface->geometry.x + dx,
1960 device->drag_surface->geometry.y + dy);
1961}
1962
1963WL_EXPORT void
1964weston_compositor_update_drag_surfaces(struct weston_compositor *compositor)
1965{
1966 weston_input_update_drag_surface(compositor->input_device, 0, 0);
1967}
1968
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001969static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001970bind_output(struct wl_client *client,
1971 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05001972{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001973 struct weston_output *output = data;
1974 struct weston_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001975 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001976
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001977 resource = wl_client_add_object(client,
1978 &wl_output_interface, NULL, id, data);
1979
1980 wl_resource_post_event(resource,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001981 WL_OUTPUT_GEOMETRY,
1982 output->x,
1983 output->y,
1984 output->mm_width,
1985 output->mm_height,
1986 output->subpixel,
1987 output->make, output->model);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001988
1989 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001990 wl_resource_post_event(resource,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001991 WL_OUTPUT_MODE,
1992 mode->flags,
1993 mode->width,
1994 mode->height,
1995 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001996 }
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001997}
1998
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001999static const char vertex_shader[] =
2000 "uniform mat4 proj;\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05002001 "attribute vec2 position;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002002 "attribute vec2 texcoord;\n"
2003 "varying vec2 v_texcoord;\n"
2004 "void main()\n"
2005 "{\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05002006 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002007 " v_texcoord = texcoord;\n"
2008 "}\n";
2009
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002010static const char texture_fragment_shader[] =
Kristian Høgsbergdfce71d2010-12-07 20:19:10 -05002011 "precision mediump float;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002012 "varying vec2 v_texcoord;\n"
2013 "uniform sampler2D tex;\n"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002014 "uniform float alpha;\n"
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02002015 "uniform float texwidth;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002016 "void main()\n"
2017 "{\n"
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02002018 " if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n"
2019 " v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n"
2020 " discard;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002021 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002022 " gl_FragColor = alpha * gl_FragColor;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002023 "}\n";
2024
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002025static const char solid_fragment_shader[] =
2026 "precision mediump float;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002027 "uniform vec4 color;\n"
2028 "void main()\n"
2029 "{\n"
2030 " gl_FragColor = color\n;"
2031 "}\n";
2032
Kristian Høgsberga9468212010-06-14 21:03:11 -04002033static int
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002034compile_shader(GLenum type, const char *source)
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002035{
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002036 GLuint s;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002037 char msg[512];
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002038 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002039
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002040 s = glCreateShader(type);
2041 glShaderSource(s, 1, &source, NULL);
2042 glCompileShader(s);
2043 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002044 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002045 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
2046 fprintf(stderr, "shader info: %s\n", msg);
2047 return GL_NONE;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002048 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002049
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002050 return s;
2051}
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002052
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002053static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002054weston_shader_init(struct weston_shader *shader,
2055 const char *vertex_source, const char *fragment_source)
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002056{
2057 char msg[512];
2058 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002059
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002060 shader->vertex_shader =
2061 compile_shader(GL_VERTEX_SHADER, vertex_source);
2062 shader->fragment_shader =
2063 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
2064
2065 shader->program = glCreateProgram();
2066 glAttachShader(shader->program, shader->vertex_shader);
2067 glAttachShader(shader->program, shader->fragment_shader);
2068 glBindAttribLocation(shader->program, 0, "position");
2069 glBindAttribLocation(shader->program, 1, "texcoord");
2070
2071 glLinkProgram(shader->program);
2072 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002073 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002074 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002075 fprintf(stderr, "link info: %s\n", msg);
2076 return -1;
2077 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002078
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002079 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
2080 shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002081 shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
Pekka Paalanenf55f5442012-02-02 16:49:05 +02002082 shader->color_uniform = glGetUniformLocation(shader->program, "color");
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02002083 shader->texwidth_uniform = glGetUniformLocation(shader->program,
2084 "texwidth");
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002085
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002086 return 0;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002087}
2088
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002089WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002090weston_output_destroy(struct weston_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002091{
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04002092 pixman_region32_fini(&output->region);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04002093 pixman_region32_fini(&output->previous_damage);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002094}
2095
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002096WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002097weston_output_move(struct weston_output *output, int x, int y)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002098{
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01002099 int flip;
2100
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002101 output->x = x;
2102 output->y = y;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002103
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04002104 pixman_region32_init(&output->previous_damage);
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04002105 pixman_region32_init_rect(&output->region, x, y,
2106 output->current->width,
2107 output->current->height);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05002108
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002109 weston_matrix_init(&output->matrix);
2110 weston_matrix_translate(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002111 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
2112 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01002113
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002114 flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002115 weston_matrix_scale(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002116 2.0 / (output->current->width + output->border.left + output->border.right),
2117 flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002118
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002119 weston_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002120}
2121
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002122WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002123weston_output_init(struct weston_output *output, struct weston_compositor *c,
2124 int x, int y, int width, int height, uint32_t flags)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002125{
2126 output->compositor = c;
2127 output->x = x;
2128 output->y = y;
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002129 output->border.top = 0;
2130 output->border.bottom = 0;
2131 output->border.left = 0;
2132 output->border.right = 0;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002133 output->mm_width = width;
2134 output->mm_height = height;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002135
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002136 output->flags = flags;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002137 weston_output_move(output, x, y);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002138
Kristian Høgsberg33418202011-08-16 23:01:28 -04002139 wl_list_init(&output->frame_callback_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02002140
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002141 wl_display_add_global(c->wl_display,
2142 &wl_output_interface, output, bind_output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002143}
2144
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002145static void
2146shm_buffer_created(struct wl_buffer *buffer)
2147{
2148 struct wl_list *surfaces_attached_to;
2149
2150 surfaces_attached_to = malloc(sizeof *surfaces_attached_to);
2151 if (!surfaces_attached_to) {
2152 buffer->user_data = NULL;
2153 return;
2154 }
2155
2156 wl_list_init(surfaces_attached_to);
2157
2158 buffer->user_data = surfaces_attached_to;
2159}
2160
2161static void
2162shm_buffer_damaged(struct wl_buffer *buffer,
2163 int32_t x, int32_t y, int32_t width, int32_t height)
2164{
2165 struct wl_list *surfaces_attached_to = buffer->user_data;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002166 struct weston_surface *es;
Benjamin Franzkefab5ec12011-04-25 19:44:47 +02002167 GLsizei tex_width = wl_shm_buffer_get_stride(buffer) / 4;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002168
2169 wl_list_for_each(es, surfaces_attached_to, buffer_link) {
2170 glBindTexture(GL_TEXTURE_2D, es->texture);
2171 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Benjamin Franzkefab5ec12011-04-25 19:44:47 +02002172 tex_width, buffer->height, 0,
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002173 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
2174 wl_shm_buffer_get_data(buffer));
2175 /* Hmm, should use glTexSubImage2D() here but GLES2 doesn't
2176 * support any unpack attributes except GL_UNPACK_ALIGNMENT. */
2177 }
2178}
2179
2180static void
2181shm_buffer_destroyed(struct wl_buffer *buffer)
2182{
2183 struct wl_list *surfaces_attached_to = buffer->user_data;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002184 struct weston_surface *es, *next;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002185
2186 wl_list_for_each_safe(es, next, surfaces_attached_to, buffer_link) {
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002187 wl_list_remove(&es->buffer_link);
Kristian Høgsbergfac11d22011-05-02 13:35:17 -04002188 wl_list_init(&es->buffer_link);
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002189 }
2190
2191 free(surfaces_attached_to);
2192}
2193
2194const static struct wl_shm_callbacks shm_callbacks = {
2195 shm_buffer_created,
2196 shm_buffer_damaged,
2197 shm_buffer_destroyed
2198};
2199
Kristian Høgsberga8873122011-11-23 10:39:34 -05002200static void
2201compositor_bind(struct wl_client *client,
2202 void *data, uint32_t version, uint32_t id)
2203{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002204 struct weston_compositor *compositor = data;
Kristian Høgsberga8873122011-11-23 10:39:34 -05002205
2206 wl_client_add_object(client, &wl_compositor_interface,
2207 &compositor_interface, id, compositor);
2208}
2209
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002210WL_EXPORT int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002211weston_compositor_init(struct weston_compositor *ec, struct wl_display *display)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002212{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002213 struct wl_event_loop *loop;
Kristian Høgsbergd711d0c2011-01-14 17:28:21 -05002214 const char *extensions;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002215
Kristian Høgsbergf9212892008-10-11 18:40:23 -04002216 ec->wl_display = display;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002217
Kristian Høgsberga8873122011-11-23 10:39:34 -05002218 if (!wl_display_add_global(display, &wl_compositor_interface,
2219 ec, compositor_bind))
2220 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05002221
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002222 ec->shm = wl_shm_init(display, &shm_callbacks);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002223
2224 ec->image_target_texture_2d =
2225 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
2226 ec->image_target_renderbuffer_storage = (void *)
2227 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
2228 ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
2229 ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
2230 ec->bind_display =
2231 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
2232 ec->unbind_display =
2233 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
2234
2235 extensions = (const char *) glGetString(GL_EXTENSIONS);
2236 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
2237 fprintf(stderr,
2238 "GL_EXT_texture_format_BGRA8888 not available\n");
2239 return -1;
2240 }
2241
2242 extensions =
2243 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
2244 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
2245 ec->has_bind_display = 1;
2246 if (ec->has_bind_display)
2247 ec->bind_display(ec->display, ec->wl_display);
Kristian Høgsberg3d5bae02010-10-06 21:17:40 -04002248
Kristian Høgsberg201a9042008-12-10 00:40:50 -05002249 wl_list_init(&ec->surface_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002250 wl_list_init(&ec->input_device_list);
2251 wl_list_init(&ec->output_list);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002252 wl_list_init(&ec->binding_list);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002253 wl_list_init(&ec->animation_list);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002254 weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002255 ec->fade.animation.frame = fade_frame;
2256 wl_list_init(&ec->fade.animation.link);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002257
Pekka Paalanen35ce06d2012-01-03 11:39:13 +02002258 ec->screenshooter = screenshooter_create(ec);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002259
Kristian Høgsbergdade6492012-01-04 21:47:30 -05002260 wl_data_device_manager_init(ec->wl_display);
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002261
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002262 glActiveTexture(GL_TEXTURE0);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002263
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002264 if (weston_shader_init(&ec->texture_shader,
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002265 vertex_shader, texture_fragment_shader) < 0)
Kristian Høgsberga9468212010-06-14 21:03:11 -04002266 return -1;
Pekka Paalanenf55f5442012-02-02 16:49:05 +02002267 if (weston_shader_init(&ec->solid_shader,
2268 vertex_shader, solid_fragment_shader) < 0)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002269 return -1;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05002270
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002271 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002272 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
Pekka Paalanen7296e792011-12-07 16:22:00 +02002273 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002274
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002275 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04002276
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002277 return 0;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002278}
2279
Benjamin Franzkeb8263022011-08-30 11:32:47 +02002280WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002281weston_compositor_shutdown(struct weston_compositor *ec)
Matt Roper361d2ad2011-08-29 13:52:23 -07002282{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002283 struct weston_output *output, *next;
Matt Roper361d2ad2011-08-29 13:52:23 -07002284
Pekka Paalanend1591ae2012-01-02 16:06:56 +02002285 wl_event_source_remove(ec->idle_source);
2286
Pekka Paalanen35ce06d2012-01-03 11:39:13 +02002287 if (ec->screenshooter)
2288 screenshooter_destroy(ec->screenshooter);
2289
Matt Roper361d2ad2011-08-29 13:52:23 -07002290 /* Destroy all outputs associated with this compositor */
Tiago Vignattib303a1d2011-12-18 22:27:40 +02002291 wl_list_for_each_safe(output, next, &ec->output_list, link)
Matt Roper361d2ad2011-08-29 13:52:23 -07002292 output->destroy(output);
Pekka Paalanen4738f3b2012-01-02 15:47:07 +02002293
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05002294 weston_binding_list_destroy_all(&ec->binding_list);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02002295
2296 wl_shm_finish(ec->shm);
2297
2298 wl_array_release(&ec->vertices);
2299 wl_array_release(&ec->indices);
Matt Roper361d2ad2011-08-29 13:52:23 -07002300}
2301
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002302static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002303{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002304 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002305
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002306 fprintf(stderr, "caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002307 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002308
2309 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002310}
2311
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002312static void
2313on_segv_signal(int s, siginfo_t *siginfo, void *context)
2314{
2315 void *buffer[32];
2316 int i, count;
2317 Dl_info info;
2318
2319 fprintf(stderr, "caught segv\n");
2320
2321 count = backtrace(buffer, ARRAY_LENGTH(buffer));
2322 for (i = 0; i < count; i++) {
2323 dladdr(buffer[i], &info);
2324 fprintf(stderr, " [%016lx] %s (%s)\n",
2325 (long) buffer[i],
2326 info.dli_sname ? info.dli_sname : "--",
2327 info.dli_fname);
2328 }
2329
2330 longjmp(segv_jmp_buf, 1);
2331}
2332
2333
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002334static void *
2335load_module(const char *name, const char *entrypoint, void **handle)
2336{
2337 char path[PATH_MAX];
2338 void *module, *init;
2339
2340 if (name[0] != '/')
2341 snprintf(path, sizeof path, MODULEDIR "/%s", name);
2342 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02002343 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002344
2345 module = dlopen(path, RTLD_LAZY);
2346 if (!module) {
2347 fprintf(stderr,
2348 "failed to load module: %s\n", dlerror());
2349 return NULL;
2350 }
2351
2352 init = dlsym(module, entrypoint);
2353 if (!init) {
2354 fprintf(stderr,
2355 "failed to lookup init function: %s\n", dlerror());
2356 return NULL;
2357 }
2358
2359 return init;
2360}
2361
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002362int main(int argc, char *argv[])
2363{
2364 struct wl_display *display;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002365 struct weston_compositor *ec;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002366 struct wl_event_source *signals[4];
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002367 struct wl_event_loop *loop;
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002368 struct sigaction segv_action;
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002369 int o, xserver = 0;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002370 void *shell_module, *backend_module;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002371 int (*shell_init)(struct weston_compositor *ec);
2372 struct weston_compositor
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002373 *(*backend_init)(struct wl_display *display, char *options);
2374 char *backend = NULL;
2375 char *backend_options = "";
2376 char *shell = NULL;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002377 char *p;
Pekka Paalanen7296e792011-12-07 16:22:00 +02002378 int option_idle_time = 300;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002379 int i;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002380
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002381 static const char opts[] = "B:b:o:S:i:s:x";
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002382 static const struct option longopts[ ] = {
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002383 { "backend", 1, NULL, 'B' },
2384 { "backend-options", 1, NULL, 'o' },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002385 { "socket", 1, NULL, 'S' },
2386 { "idle-time", 1, NULL, 'i' },
2387 { "shell", 1, NULL, 's' },
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002388 { "xserver", 0, NULL, 'x' },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002389 { NULL, }
2390 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05002391
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002392 while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) {
2393 switch (o) {
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002394 case 'B':
2395 backend = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002396 break;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002397 case 'o':
2398 backend_options = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002399 break;
2400 case 'S':
2401 option_socket_name = optarg;
2402 break;
2403 case 'i':
2404 option_idle_time = strtol(optarg, &p, 0);
2405 if (*p != '\0') {
2406 fprintf(stderr,
2407 "invalid idle time option: %s\n",
2408 optarg);
2409 exit(EXIT_FAILURE);
2410 }
2411 break;
2412 case 's':
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002413 shell = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002414 break;
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002415 case 'x':
2416 xserver = 1;
2417 break;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002418 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04002419 }
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002420
2421 display = wl_display_create();
2422
Tiago Vignatti2116b892011-08-08 05:52:59 -07002423 loop = wl_display_get_event_loop(display);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002424 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
2425 display);
2426 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
2427 display);
2428 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
2429 display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07002430
2431 wl_list_init(&child_process_list);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002432 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
2433 NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05002434
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002435 segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
2436 segv_action.sa_sigaction = on_segv_signal;
Pekka Paalanen8423a892012-01-19 16:48:37 +02002437 sigemptyset(&segv_action.sa_mask);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002438 sigaction(SIGSEGV, &segv_action, NULL);
2439
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002440 if (!backend) {
2441 if (getenv("WAYLAND_DISPLAY"))
2442 backend = "wayland-backend.so";
2443 else if (getenv("DISPLAY"))
2444 backend = "x11-backend.so";
2445 else if (getenv("OPENWFD"))
2446 backend = "openwfd-backend.so";
2447 else
2448 backend = "drm-backend.so";
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04002449 }
2450
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002451 if (!shell)
2452 shell = "desktop-shell.so";
Kristian Høgsberga9410222011-01-14 17:22:35 -05002453
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002454 backend_init = load_module(backend, "backend_init", &backend_module);
2455 if (!backend_init)
2456 exit(EXIT_FAILURE);
Kristian Høgsberga9410222011-01-14 17:22:35 -05002457
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002458 shell_init = load_module(shell, "shell_init", &shell_module);
2459 if (!shell_init)
2460 exit(EXIT_FAILURE);
Benjamin Franzke5d007092011-04-04 00:30:25 +02002461
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002462 ec = backend_init(display, backend_options);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05002463 if (ec == NULL) {
2464 fprintf(stderr, "failed to create compositor\n");
2465 exit(EXIT_FAILURE);
2466 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04002467
Pekka Paalanen7296e792011-12-07 16:22:00 +02002468 ec->option_idle_time = option_idle_time;
2469 ec->idle_time = option_idle_time;
2470
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002471 if (xserver)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002472 weston_xserver_init(ec);
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002473
Kristian Høgsberg1760ebb2012-01-15 16:04:33 -05002474 if (shell_init(ec) < 0)
2475 exit(EXIT_FAILURE);
2476
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05002477 if (wl_display_add_socket(display, option_socket_name)) {
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002478 fprintf(stderr, "failed to add socket: %m\n");
2479 exit(EXIT_FAILURE);
2480 }
2481
Pekka Paalanenc0444e32012-01-05 16:28:21 +02002482 weston_compositor_wake(ec);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05002483 if (setjmp(segv_jmp_buf) == 0)
2484 wl_display_run(display);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002485
Pekka Paalanen0135abe2012-01-03 10:01:20 +02002486 /* prevent further rendering while shutting down */
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05002487 ec->state = WESTON_COMPOSITOR_SLEEPING;
Pekka Paalanen0135abe2012-01-03 10:01:20 +02002488
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002489 if (xserver)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002490 weston_xserver_destroy(ec);
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002491
Pekka Paalanen3c647232011-12-22 13:43:43 +02002492 ec->shell->destroy(ec->shell);
2493
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002494 if (ec->has_bind_display)
2495 ec->unbind_display(ec->display, display);
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05002496
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002497 for (i = ARRAY_LENGTH(signals); i;)
2498 wl_event_source_remove(signals[--i]);
2499
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002500 ec->destroy(ec);
Tiago Vignatti9e2be082011-12-19 00:04:46 +02002501 wl_display_destroy(display);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002502
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002503 return 0;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002504}