blob: b904861e3782148853b75aedb9a2b108bffdaec9 [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
Daniel Stoneb7452fe2012-06-01 12:14:06 +010029#include <fcntl.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040030#include <stdio.h>
31#include <string.h>
32#include <stdlib.h>
33#include <stdint.h>
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +010034#include <limits.h>
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -050035#include <stdarg.h>
Benjamin Franzke6f5fc692011-06-21 19:34:19 +020036#include <assert.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040037#include <sys/ioctl.h>
Daniel Stoneb7452fe2012-06-01 12:14:06 +010038#include <sys/mman.h>
Kristian Høgsberg27da5382011-06-21 17:32:25 -040039#include <sys/wait.h>
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020040#include <sys/socket.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040041#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øgsberg85449032011-05-02 12:11:07 -040045#include <signal.h>
Kristian Høgsberg0690da62012-01-16 11:53:54 -050046#include <setjmp.h>
Kristian Høgsberg890bc052008-12-30 14:31:33 -050047
Pekka Paalanen50719bc2011-11-22 14:18:50 +020048#include <wayland-server.h>
Kristian Høgsberg82863022010-06-04 21:52:02 -040049#include "compositor.h"
Pekka Paalanen51aaf642012-05-30 15:53:41 +030050#include "../shared/os-compatibility.h"
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050051
Kristian Høgsberg27da5382011-06-21 17:32:25 -040052static struct wl_list child_process_list;
Kristian Høgsberg0690da62012-01-16 11:53:54 -050053static jmp_buf segv_jmp_buf;
Kristian Høgsberg27da5382011-06-21 17:32:25 -040054
55static int
56sigchld_handler(int signal_number, void *data)
57{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050058 struct weston_process *p;
Kristian Høgsberg27da5382011-06-21 17:32:25 -040059 int status;
60 pid_t pid;
61
Bill Spitzak027b9622012-03-17 15:22:03 -070062 pid = waitpid(-1, &status, WNOHANG);
63 if (!pid)
64 return 1;
65
Kristian Høgsberg27da5382011-06-21 17:32:25 -040066 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
Alex Wu2dda6042012-04-17 17:20:47 +080082WL_EXPORT int
83weston_output_switch_mode(struct weston_output *output, struct weston_mode *mode)
84{
85 if (!output->switch_mode)
86 return -1;
87
88 return output->switch_mode(output, mode);
89}
90
Kristian Høgsberg27da5382011-06-21 17:32:25 -040091WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050092weston_watch_process(struct weston_process *process)
Kristian Høgsberg27da5382011-06-21 17:32:25 -040093{
94 wl_list_insert(&child_process_list, &process->link);
95}
96
Benjamin Franzke06286262011-05-06 19:12:33 +020097static void
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020098child_client_exec(int sockfd, const char *path)
99{
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500100 int clientfd;
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200101 char s[32];
Pekka Paalanenc47ddfd2011-12-08 10:44:56 +0200102 sigset_t allsigs;
103
104 /* do not give our signal mask to the new process */
105 sigfillset(&allsigs);
106 sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200107
Kristian Høgsbergeb764842012-01-31 22:17:25 -0500108 /* Launch clients as the user. */
109 seteuid(getuid());
110
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500111 /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
112 * non-CLOEXEC fd to pass through exec. */
113 clientfd = dup(sockfd);
114 if (clientfd == -1) {
115 fprintf(stderr, "compositor: dup failed: %m\n");
116 return;
117 }
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200118
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500119 snprintf(s, sizeof s, "%d", clientfd);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200120 setenv("WAYLAND_SOCKET", s, 1);
121
122 if (execl(path, path, NULL) < 0)
123 fprintf(stderr, "compositor: executing '%s' failed: %m\n",
124 path);
125}
126
127WL_EXPORT struct wl_client *
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500128weston_client_launch(struct weston_compositor *compositor,
129 struct weston_process *proc,
130 const char *path,
131 weston_process_cleanup_func_t cleanup)
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200132{
133 int sv[2];
134 pid_t pid;
135 struct wl_client *client;
136
Pekka Paalanen51aaf642012-05-30 15:53:41 +0300137 if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500138 fprintf(stderr, "weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200139 "socketpair failed while launching '%s': %m\n",
140 path);
141 return NULL;
142 }
143
144 pid = fork();
145 if (pid == -1) {
146 close(sv[0]);
147 close(sv[1]);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500148 fprintf(stderr, "weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200149 "fork failed while launching '%s': %m\n", path);
150 return NULL;
151 }
152
153 if (pid == 0) {
154 child_client_exec(sv[1], path);
155 exit(-1);
156 }
157
158 close(sv[1]);
159
160 client = wl_client_create(compositor->wl_display, sv[0]);
161 if (!client) {
162 close(sv[0]);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500163 fprintf(stderr, "weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200164 "wl_client_create failed while launching '%s'.\n",
165 path);
166 return NULL;
167 }
168
169 proc->pid = pid;
170 proc->cleanup = cleanup;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500171 weston_watch_process(proc);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200172
173 return client;
174}
175
176static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400177surface_handle_buffer_destroy(struct wl_listener *listener, void *data)
Benjamin Franzke06286262011-05-06 19:12:33 +0200178{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500179 struct weston_surface *es =
180 container_of(listener, struct weston_surface,
181 buffer_destroy_listener);
Benjamin Franzke06286262011-05-06 19:12:33 +0200182
Kristian Høgsberg24596942011-10-24 17:51:02 -0400183 es->buffer = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200184}
185
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500186static const pixman_region32_data_t undef_region_data;
187
188static void
189undef_region(pixman_region32_t *region)
190{
Kristian Høgsberg66a099b2012-05-29 16:49:45 -0400191 if (region->data != &undef_region_data)
192 pixman_region32_fini(region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500193 region->data = (pixman_region32_data_t *) &undef_region_data;
194}
195
196static int
197region_is_undefined(pixman_region32_t *region)
198{
199 return region->data == &undef_region_data;
200}
201
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +0200202static void
203empty_region(pixman_region32_t *region)
204{
205 if (!region_is_undefined(region))
206 pixman_region32_fini(region);
207
208 pixman_region32_init(region);
209}
210
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500211WL_EXPORT struct weston_surface *
Kristian Høgsberg18c93002012-01-27 11:58:31 -0500212weston_surface_create(struct weston_compositor *compositor)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500213{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500214 struct weston_surface *surface;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400215
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200216 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400217 if (surface == NULL)
218 return NULL;
219
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400220 wl_signal_init(&surface->surface.resource.destroy_signal);
Kristian Høgsberg48891542012-02-23 17:38:33 -0500221
Kristian Høgsbergf6b14712011-01-06 15:32:14 -0500222 wl_list_init(&surface->link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500223 wl_list_init(&surface->layer_link);
Kristian Høgsbergc551bd22010-12-06 16:43:16 -0500224
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400225 surface->surface.resource.client = NULL;
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400226
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500227 surface->compositor = compositor;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200228 surface->image = EGL_NO_IMAGE_KHR;
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400229 surface->alpha = 1.0;
230 surface->brightness = 1.0;
231 surface->saturation = 1.0;
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400232 surface->blend = 1;
Kristian Høgsberg0b0c2bb2012-05-15 23:16:53 -0400233 surface->opaque_rect[0] = 0.0;
234 surface->opaque_rect[1] = 0.0;
235 surface->opaque_rect[2] = 0.0;
236 surface->opaque_rect[3] = 0.0;
Juan Zhao46436612012-03-20 01:48:46 +0800237 surface->pitch = 1;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400238
Benjamin Franzke06286262011-05-06 19:12:33 +0200239 surface->buffer = NULL;
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400240 surface->output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200241
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400242 pixman_region32_init(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500243 pixman_region32_init(&surface->opaque);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500244 pixman_region32_init(&surface->clip);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500245 undef_region(&surface->input);
Pekka Paalanen730d87e2012-02-09 16:39:38 +0200246 pixman_region32_init(&surface->transform.opaque);
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500247 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400248
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -0400249 surface->buffer_destroy_listener.notify =
250 surface_handle_buffer_destroy;
Benjamin Franzke06286262011-05-06 19:12:33 +0200251
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200252 wl_list_init(&surface->geometry.transformation_list);
Pekka Paalanencd403622012-01-25 13:37:39 +0200253 wl_list_insert(&surface->geometry.transformation_list,
254 &surface->transform.position.link);
255 weston_matrix_init(&surface->transform.position.matrix);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200256 pixman_region32_init(&surface->transform.boundingbox);
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200257 surface->geometry.dirty = 1;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500258
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400259 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500260}
261
Alex Wu8811bf92012-02-28 18:07:54 +0800262WL_EXPORT void
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500263weston_surface_set_color(struct weston_surface *surface,
264 GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
265{
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500266 surface->color[0] = red;
267 surface->color[1] = green;
268 surface->color[2] = blue;
269 surface->color[3] = alpha;
270 surface->shader = &surface->compositor->solid_shader;
271}
272
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200273static void
Pekka Paalanenece8a012012-02-08 15:23:15 +0200274surface_to_global_float(struct weston_surface *surface,
Daniel Stonebd3489b2012-05-08 17:17:53 +0100275 GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y)
Pekka Paalanenece8a012012-02-08 15:23:15 +0200276{
277 if (surface->transform.enabled) {
278 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
279
280 weston_matrix_transform(&surface->transform.matrix, &v);
281
282 if (fabsf(v.f[3]) < 1e-6) {
283 fprintf(stderr, "warning: numerical instability in "
284 "weston_surface_to_global(), divisor = %g\n",
285 v.f[3]);
286 *x = 0;
287 *y = 0;
288 return;
289 }
290
291 *x = v.f[0] / v.f[3];
292 *y = v.f[1] / v.f[3];
293 } else {
294 *x = sx + surface->geometry.x;
295 *y = sy + surface->geometry.y;
296 }
297}
298
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500299WL_EXPORT void
Kristian Høgsberg323ee042012-02-17 12:45:43 -0500300weston_surface_damage_below(struct weston_surface *surface)
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200301{
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500302 struct weston_compositor *compositor = surface->compositor;
303 pixman_region32_t damage;
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200304
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500305 pixman_region32_init(&damage);
306 pixman_region32_subtract(&damage, &surface->transform.boundingbox,
307 &surface->clip);
308 pixman_region32_union(&compositor->damage,
309 &compositor->damage, &damage);
310 pixman_region32_fini(&damage);
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200311}
312
313static void
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200314surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy,
315 int32_t width, int32_t height,
316 pixman_region32_t *bbox)
317{
Pekka Paalanen219b9822012-02-08 15:38:37 +0200318 GLfloat min_x = HUGE_VALF, min_y = HUGE_VALF;
319 GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200320 int32_t s[4][2] = {
321 { sx, sy },
322 { sx, sy + height },
323 { sx + width, sy },
324 { sx + width, sy + height }
325 };
Pekka Paalanen219b9822012-02-08 15:38:37 +0200326 GLfloat int_x, int_y;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200327 int i;
328
329 for (i = 0; i < 4; ++i) {
Pekka Paalanen219b9822012-02-08 15:38:37 +0200330 GLfloat x, y;
331 surface_to_global_float(surface, s[i][0], s[i][1], &x, &y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200332 if (x < min_x)
333 min_x = x;
334 if (x > max_x)
335 max_x = x;
336 if (y < min_y)
337 min_y = y;
338 if (y > max_y)
339 max_y = y;
340 }
341
Pekka Paalanen219b9822012-02-08 15:38:37 +0200342 int_x = floorf(min_x);
343 int_y = floorf(min_y);
344 pixman_region32_init_rect(bbox, int_x, int_y,
345 ceilf(max_x) - int_x, ceilf(max_y) - int_y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200346}
347
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200348static void
349weston_surface_update_transform_disable(struct weston_surface *surface)
350{
351 surface->transform.enabled = 0;
352
Pekka Paalanencc2f8682012-02-13 10:34:04 +0200353 /* round off fractions when not transformed */
354 surface->geometry.x = roundf(surface->geometry.x);
355 surface->geometry.y = roundf(surface->geometry.y);
356
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200357 pixman_region32_init_rect(&surface->transform.boundingbox,
358 surface->geometry.x,
359 surface->geometry.y,
360 surface->geometry.width,
361 surface->geometry.height);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500362
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400363 if (surface->alpha == 1.0) {
Kristian Høgsberg3b4af202012-02-28 09:19:39 -0500364 pixman_region32_copy(&surface->transform.opaque,
365 &surface->opaque);
366 pixman_region32_translate(&surface->transform.opaque,
367 surface->geometry.x,
368 surface->geometry.y);
369 }
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200370}
371
372static int
373weston_surface_update_transform_enable(struct weston_surface *surface)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200374{
375 struct weston_matrix *matrix = &surface->transform.matrix;
376 struct weston_matrix *inverse = &surface->transform.inverse;
377 struct weston_transform *tform;
378
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200379 surface->transform.enabled = 1;
380
381 /* Otherwise identity matrix, but with x and y translation. */
382 surface->transform.position.matrix.d[12] = surface->geometry.x;
383 surface->transform.position.matrix.d[13] = surface->geometry.y;
384
385 weston_matrix_init(matrix);
386 wl_list_for_each(tform, &surface->geometry.transformation_list, link)
387 weston_matrix_multiply(matrix, &tform->matrix);
388
389 if (weston_matrix_invert(inverse, matrix) < 0) {
390 /* Oops, bad total transformation, not invertible */
391 fprintf(stderr, "error: weston_surface %p"
392 " transformation not invertible.\n", surface);
393 return -1;
394 }
395
396 surface_compute_bbox(surface, 0, 0, surface->geometry.width,
397 surface->geometry.height,
398 &surface->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500399
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200400 return 0;
401}
402
403WL_EXPORT void
404weston_surface_update_transform(struct weston_surface *surface)
405{
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200406 if (!surface->geometry.dirty)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200407 return;
408
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200409 surface->geometry.dirty = 0;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200410
Kristian Høgsberg323ee042012-02-17 12:45:43 -0500411 weston_surface_damage_below(surface);
Pekka Paalanen96516782012-02-09 15:32:15 +0200412
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200413 pixman_region32_fini(&surface->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500414 pixman_region32_fini(&surface->transform.opaque);
415 pixman_region32_init(&surface->transform.opaque);
416
417 if (region_is_undefined(&surface->input))
418 pixman_region32_init_rect(&surface->input, 0, 0,
419 surface->geometry.width,
420 surface->geometry.height);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200421
Pekka Paalanencd403622012-01-25 13:37:39 +0200422 /* transform.position is always in transformation_list */
423 if (surface->geometry.transformation_list.next ==
424 &surface->transform.position.link &&
425 surface->geometry.transformation_list.prev ==
426 &surface->transform.position.link) {
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200427 weston_surface_update_transform_disable(surface);
428 } else {
429 if (weston_surface_update_transform_enable(surface) < 0)
430 weston_surface_update_transform_disable(surface);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200431 }
Pekka Paalanen96516782012-02-09 15:32:15 +0200432
433 /* weston_surface_damage() without update */
434 pixman_region32_union(&surface->damage, &surface->damage,
435 &surface->transform.boundingbox);
436
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300437 if (weston_surface_is_mapped(surface))
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +0200438 weston_surface_assign_output(surface);
439
Pekka Paalanen96516782012-02-09 15:32:15 +0200440 weston_compositor_schedule_repaint(surface->compositor);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200441}
442
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200443WL_EXPORT void
Ander Conselvan de Oliveirafbf28942012-03-27 17:36:37 +0300444weston_surface_to_global_float(struct weston_surface *surface,
Daniel Stonebd3489b2012-05-08 17:17:53 +0100445 GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y)
Ander Conselvan de Oliveirafbf28942012-03-27 17:36:37 +0300446{
Ander Conselvan de Oliveirafbf28942012-03-27 17:36:37 +0300447 surface_to_global_float(surface, sx, sy, x, y);
448}
449
450WL_EXPORT void
Daniel Stonebd3489b2012-05-08 17:17:53 +0100451weston_surface_to_global_fixed(struct weston_surface *surface,
452 wl_fixed_t sx, wl_fixed_t sy,
453 wl_fixed_t *x, wl_fixed_t *y)
454{
455 GLfloat xf, yf;
456
457 weston_surface_to_global_float(surface,
458 wl_fixed_to_double(sx),
459 wl_fixed_to_double(sy),
460 &xf, &yf);
461 *x = wl_fixed_from_double(xf);
462 *y = wl_fixed_from_double(yf);
463}
464
465WL_EXPORT void
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200466weston_surface_to_global(struct weston_surface *surface,
467 int32_t sx, int32_t sy, int32_t *x, int32_t *y)
468{
469 GLfloat xf, yf;
470
Ander Conselvan de Oliveirafbf28942012-03-27 17:36:37 +0300471 weston_surface_to_global_float(surface, sx, sy, &xf, &yf);
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200472 *x = floorf(xf);
473 *y = floorf(yf);
474}
475
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200476static void
477surface_from_global_float(struct weston_surface *surface,
Daniel Stonebd3489b2012-05-08 17:17:53 +0100478 GLfloat x, GLfloat y, GLfloat *sx, GLfloat *sy)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200479{
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200480 if (surface->transform.enabled) {
481 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
482
483 weston_matrix_transform(&surface->transform.inverse, &v);
484
485 if (fabsf(v.f[3]) < 1e-6) {
486 fprintf(stderr, "warning: numerical instability in "
487 "weston_surface_from_global(), divisor = %g\n",
488 v.f[3]);
489 *sx = 0;
490 *sy = 0;
491 return;
492 }
493
Pekka Paalanencd403622012-01-25 13:37:39 +0200494 *sx = v.f[0] / v.f[3];
495 *sy = v.f[1] / v.f[3];
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200496 } else {
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200497 *sx = x - surface->geometry.x;
498 *sy = y - surface->geometry.y;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200499 }
500}
501
502WL_EXPORT void
Daniel Stonebd3489b2012-05-08 17:17:53 +0100503weston_surface_from_global_fixed(struct weston_surface *surface,
504 wl_fixed_t x, wl_fixed_t y,
505 wl_fixed_t *sx, wl_fixed_t *sy)
506{
507 GLfloat sxf, syf;
508
Daniel Stonebd3489b2012-05-08 17:17:53 +0100509 surface_from_global_float(surface,
510 wl_fixed_to_double(x),
511 wl_fixed_to_double(y),
512 &sxf, &syf);
513 *sx = wl_fixed_from_double(sxf);
514 *sy = wl_fixed_from_double(syf);
515}
516
517WL_EXPORT void
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200518weston_surface_from_global(struct weston_surface *surface,
519 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
520{
521 GLfloat sxf, syf;
522
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200523 surface_from_global_float(surface, x, y, &sxf, &syf);
524 *sx = floorf(sxf);
525 *sy = floorf(syf);
526}
527
Tiago Vignatti9d393522012-02-10 16:26:19 +0200528static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500529weston_surface_damage_rectangle(struct weston_surface *surface,
Pekka Paalanen2267d452012-01-26 13:12:45 +0200530 int32_t sx, int32_t sy,
531 int32_t width, int32_t height)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500532{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200533 if (surface->transform.enabled) {
534 pixman_region32_t box;
535 surface_compute_bbox(surface, sx, sy, width, height, &box);
536 pixman_region32_union(&surface->damage, &surface->damage,
537 &box);
538 pixman_region32_fini(&box);
539 } else {
Pekka Paalanen2267d452012-01-26 13:12:45 +0200540 pixman_region32_union_rect(&surface->damage, &surface->damage,
Pekka Paalanen1d5035c2012-02-09 15:27:45 +0200541 surface->geometry.x + sx,
542 surface->geometry.y + sy,
543 width, height);
Pekka Paalanen2267d452012-01-26 13:12:45 +0200544 }
545
546 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500547}
548
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400549WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500550weston_surface_damage(struct weston_surface *surface)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500551{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200552 pixman_region32_union(&surface->damage, &surface->damage,
553 &surface->transform.boundingbox);
554
555 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500556}
557
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400558WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500559weston_surface_configure(struct weston_surface *surface,
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200560 GLfloat x, GLfloat y, int width, int height)
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400561{
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200562 surface->geometry.x = x;
563 surface->geometry.y = y;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200564 surface->geometry.width = width;
565 surface->geometry.height = height;
Pekka Paalanencd403622012-01-25 13:37:39 +0200566 surface->geometry.dirty = 1;
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400567}
568
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +0200569WL_EXPORT void
570weston_surface_set_position(struct weston_surface *surface,
571 GLfloat x, GLfloat y)
572{
573 surface->geometry.x = x;
574 surface->geometry.y = y;
575 surface->geometry.dirty = 1;
576}
577
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300578WL_EXPORT int
579weston_surface_is_mapped(struct weston_surface *surface)
580{
581 if (surface->output)
582 return 1;
583 else
584 return 0;
585}
586
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400587WL_EXPORT uint32_t
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500588weston_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500589{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400590 struct timeval tv;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500591
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400592 gettimeofday(&tv, NULL);
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500593
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400594 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500595}
596
Tiago Vignatti9d393522012-02-10 16:26:19 +0200597static struct weston_surface *
598weston_compositor_pick_surface(struct weston_compositor *compositor,
Daniel Stone103db7f2012-05-08 17:17:55 +0100599 wl_fixed_t x, wl_fixed_t y,
600 wl_fixed_t *sx, wl_fixed_t *sy)
Tiago Vignatti9d393522012-02-10 16:26:19 +0200601{
602 struct weston_surface *surface;
603
604 wl_list_for_each(surface, &compositor->surface_list, link) {
Daniel Stone103db7f2012-05-08 17:17:55 +0100605 weston_surface_from_global_fixed(surface, x, y, sx, sy);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500606 if (pixman_region32_contains_point(&surface->input,
Daniel Stone103db7f2012-05-08 17:17:55 +0100607 wl_fixed_to_int(*sx),
608 wl_fixed_to_int(*sy),
609 NULL))
Tiago Vignatti9d393522012-02-10 16:26:19 +0200610 return surface;
611 }
612
613 return NULL;
614}
615
616static void
Daniel Stone37816df2012-05-16 18:45:18 +0100617weston_device_repick(struct wl_seat *seat)
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500618{
Daniel Stone37816df2012-05-16 18:45:18 +0100619 struct weston_seat *ws = (struct weston_seat *) seat;
Scott Moreau447013d2012-02-18 05:05:29 -0700620 const struct wl_pointer_grab_interface *interface;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500621 struct weston_surface *surface, *focus;
622
Daniel Stonee9e92d22012-06-04 11:40:47 +0100623 if (!seat->pointer)
624 return;
625
Daniel Stone37816df2012-05-16 18:45:18 +0100626 surface = weston_compositor_pick_surface(ws->compositor,
627 seat->pointer->x,
628 seat->pointer->y,
629 &seat->pointer->current_x,
630 &seat->pointer->current_y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500631
Daniel Stone37816df2012-05-16 18:45:18 +0100632 if (&surface->surface != seat->pointer->current) {
633 interface = seat->pointer->grab->interface;
634 interface->focus(seat->pointer->grab, &surface->surface,
635 seat->pointer->current_x,
636 seat->pointer->current_y);
637 seat->pointer->current = &surface->surface;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500638 }
639
Daniel Stone37816df2012-05-16 18:45:18 +0100640 focus = (struct weston_surface *) seat->pointer->grab->focus;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500641 if (focus)
Daniel Stone37816df2012-05-16 18:45:18 +0100642 weston_surface_from_global_fixed(focus,
643 seat->pointer->x,
644 seat->pointer->y,
645 &seat->pointer->grab->x,
646 &seat->pointer->grab->y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500647}
648
649WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500650weston_compositor_repick(struct weston_compositor *compositor)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400651{
Daniel Stone37816df2012-05-16 18:45:18 +0100652 struct weston_seat *seat;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400653
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500654 if (!compositor->focus)
655 return;
656
Daniel Stone37816df2012-05-16 18:45:18 +0100657 wl_list_for_each(seat, &compositor->seat_list, link)
658 weston_device_repick(&seat->seat);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400659}
660
661static void
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500662weston_surface_unmap(struct weston_surface *surface)
663{
Daniel Stone4dab5db2012-05-30 16:31:53 +0100664 struct weston_seat *seat;
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500665
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500666 weston_surface_damage_below(surface);
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500667 surface->output = NULL;
668 wl_list_remove(&surface->link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500669 wl_list_remove(&surface->layer_link);
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500670
Daniel Stone4dab5db2012-05-30 16:31:53 +0100671 wl_list_for_each(seat, &surface->compositor->seat_list, link) {
Daniel Stonee9e92d22012-06-04 11:40:47 +0100672 if (seat->seat.keyboard &&
673 seat->seat.keyboard->focus == &surface->surface)
Daniel Stone4dab5db2012-05-30 16:31:53 +0100674 wl_keyboard_set_focus(seat->seat.keyboard, NULL);
Daniel Stonee9e92d22012-06-04 11:40:47 +0100675 if (seat->seat.pointer &&
676 seat->seat.pointer->focus == &surface->surface)
Daniel Stone4dab5db2012-05-30 16:31:53 +0100677 wl_pointer_set_focus(seat->seat.pointer,
678 NULL,
679 wl_fixed_from_int(0),
680 wl_fixed_from_int(0));
681 }
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500682
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500683 weston_compositor_schedule_repaint(surface->compositor);
684}
685
686static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400687destroy_surface(struct wl_resource *resource)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500688{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500689 struct weston_surface *surface =
690 container_of(resource,
691 struct weston_surface, surface.resource);
692 struct weston_compositor *compositor = surface->compositor;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400693
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300694 if (weston_surface_is_mapped(surface))
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500695 weston_surface_unmap(surface);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400696
Kristian Høgsberg12bbf812012-02-17 12:15:27 -0500697 if (surface->texture)
698 glDeleteTextures(1, &surface->texture);
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200699
Benjamin Franzke06286262011-05-06 19:12:33 +0200700 if (surface->buffer)
701 wl_list_remove(&surface->buffer_destroy_listener.link);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400702
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200703 if (surface->image != EGL_NO_IMAGE_KHR)
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400704 compositor->destroy_image(compositor->display,
705 surface->image);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200706
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200707 pixman_region32_fini(&surface->transform.boundingbox);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200708 pixman_region32_fini(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500709 pixman_region32_fini(&surface->opaque);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500710 pixman_region32_fini(&surface->clip);
Kristian Høgsbergdd631c12012-02-23 16:20:38 -0500711 if (!region_is_undefined(&surface->input))
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500712 pixman_region32_fini(&surface->input);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200713
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400714 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500715}
716
Alex Wu8811bf92012-02-28 18:07:54 +0800717WL_EXPORT void
718weston_surface_destroy(struct weston_surface *surface)
719{
720 /* Not a valid way to destroy a client surface */
721 assert(surface->surface.resource.client == NULL);
722
723 destroy_surface(&surface->surface.resource);
724}
725
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100726static void
Kristian Høgsberg8cbfb2a2012-03-27 17:04:59 -0400727weston_surface_attach(struct wl_surface *surface, struct wl_buffer *buffer)
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100728{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500729 struct weston_surface *es = (struct weston_surface *) surface;
730 struct weston_compositor *ec = es->compositor;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100731
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300732 if (es->buffer) {
733 weston_buffer_post_release(es->buffer);
734 wl_list_remove(&es->buffer_destroy_listener.link);
735 }
736
737 es->buffer = buffer;
738
739 if (!buffer) {
740 if (weston_surface_is_mapped(es))
741 weston_surface_unmap(es);
742 return;
743 }
744
745 buffer->busy_count++;
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400746 wl_signal_add(&es->buffer->resource.destroy_signal,
747 &es->buffer_destroy_listener);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300748
749 if (es->geometry.width != buffer->width ||
750 es->geometry.height != buffer->height) {
751 undef_region(&es->input);
752 pixman_region32_fini(&es->opaque);
753 pixman_region32_init(&es->opaque);
754 }
755
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500756 if (!es->texture) {
757 glGenTextures(1, &es->texture);
758 glBindTexture(GL_TEXTURE_2D, es->texture);
759 glTexParameteri(GL_TEXTURE_2D,
760 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
761 glTexParameteri(GL_TEXTURE_2D,
762 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
763 es->shader = &ec->texture_shader;
764 } else {
765 glBindTexture(GL_TEXTURE_2D, es->texture);
766 }
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100767
768 if (wl_buffer_is_shm(buffer)) {
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200769 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
Kristian Høgsbergfb6de222012-03-27 17:10:13 -0400770 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
771 es->pitch, es->buffer->height, 0,
772 GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400773 if (wl_shm_buffer_get_format(buffer) == WL_SHM_FORMAT_XRGB8888)
774 es->blend = 0;
775 else
776 es->blend = 1;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100777 } else {
Benjamin Franzkefb4b5a22011-06-21 10:44:37 +0200778 if (es->image != EGL_NO_IMAGE_KHR)
779 ec->destroy_image(ec->display, es->image);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400780 es->image = ec->create_image(ec->display, NULL,
781 EGL_WAYLAND_BUFFER_WL,
782 buffer, NULL);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300783
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400784 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400785
Ander Conselvan de Oliveira9390ae32012-03-27 17:36:38 +0300786 es->pitch = buffer->width;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100787 }
788}
789
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400790static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500791texture_region(struct weston_surface *es, pixman_region32_t *region)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500792{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500793 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500794 GLfloat *v, inv_width, inv_height;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200795 GLfloat sx, sy;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500796 pixman_box32_t *rectangles;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400797 unsigned int *p;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500798 int i, n;
799
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400800 rectangles = pixman_region32_rectangles(region, &n);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500801 v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
802 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200803 inv_width = 1.0 / es->pitch;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200804 inv_height = 1.0 / es->geometry.height;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400805
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500806 for (i = 0; i < n; i++, v += 16, p += 6) {
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200807 surface_from_global_float(es, rectangles[i].x1,
808 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500809 v[ 0] = rectangles[i].x1;
810 v[ 1] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200811 v[ 2] = sx * inv_width;
812 v[ 3] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500813
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200814 surface_from_global_float(es, rectangles[i].x1,
815 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500816 v[ 4] = rectangles[i].x1;
817 v[ 5] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200818 v[ 6] = sx * inv_width;
819 v[ 7] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500820
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200821 surface_from_global_float(es, rectangles[i].x2,
822 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500823 v[ 8] = rectangles[i].x2;
824 v[ 9] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200825 v[10] = sx * inv_width;
826 v[11] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500827
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200828 surface_from_global_float(es, rectangles[i].x2,
829 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500830 v[12] = rectangles[i].x2;
831 v[13] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200832 v[14] = sx * inv_width;
833 v[15] = sy * inv_height;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500834
835 p[0] = i * 4 + 0;
836 p[1] = i * 4 + 1;
837 p[2] = i * 4 + 2;
838 p[3] = i * 4 + 2;
839 p[4] = i * 4 + 1;
840 p[5] = i * 4 + 3;
841 }
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500842
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400843 return n;
844}
845
Kristian Høgsberg68c479a2012-01-25 23:32:28 -0500846WL_EXPORT void
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500847weston_surface_draw(struct weston_surface *es, struct weston_output *output,
848 pixman_region32_t *damage)
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400849{
Scott Moreau9fb98242012-05-22 10:18:50 -0600850 GLfloat surface_rect[4] = { 0.0, 1.0, 0.0, 1.0 };
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500851 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400852 GLfloat *v;
853 pixman_region32_t repaint;
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400854 GLint filter;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400855 int n;
856
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200857 pixman_region32_init(&repaint);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500858 pixman_region32_intersect(&repaint,
859 &es->transform.boundingbox, damage);
860 pixman_region32_subtract(&repaint, &repaint, &es->clip);
Pekka Paalanenc7b45f62012-02-06 12:16:07 +0200861
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400862 if (!pixman_region32_not_empty(&repaint))
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200863 goto out;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400864
Kristian Høgsberg101cb652012-02-17 10:45:16 -0500865 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
Scott Moreau9fb98242012-05-22 10:18:50 -0600866 if (es->blend || es->alpha < 1.0)
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400867 glEnable(GL_BLEND);
868 else
869 glDisable(GL_BLEND);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400870
Kristian Høgsberg07632622012-01-25 23:02:06 -0500871 if (ec->current_shader != es->shader) {
872 glUseProgram(es->shader->program);
Kristian Høgsberg07632622012-01-25 23:02:06 -0500873 ec->current_shader = es->shader;
874 }
875
Kristian Høgsberg0452abc2012-01-31 15:38:36 -0500876 glUniformMatrix4fv(es->shader->proj_uniform,
877 1, GL_FALSE, output->matrix.d);
Pekka Paalanenf55f5442012-02-02 16:49:05 +0200878 glUniform1i(es->shader->tex_uniform, 0);
879 glUniform4fv(es->shader->color_uniform, 1, es->color);
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400880 glUniform1f(es->shader->alpha_uniform, es->alpha);
881 glUniform1f(es->shader->brightness_uniform, es->brightness);
882 glUniform1f(es->shader->saturation_uniform, es->saturation);
Pekka Paalanenf55f5442012-02-02 16:49:05 +0200883 glUniform1f(es->shader->texwidth_uniform,
884 (GLfloat)es->geometry.width / es->pitch);
Scott Moreau9fb98242012-05-22 10:18:50 -0600885 if (es->blend)
886 glUniform4fv(es->shader->opaque_uniform, 1, es->opaque_rect);
887 else
888 glUniform4fv(es->shader->opaque_uniform, 1, surface_rect);
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200889
Scott Moreauccbf29d2012-02-22 14:21:41 -0700890 if (es->transform.enabled || output->zoom.active)
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400891 filter = GL_LINEAR;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200892 else
Pekka Paalanenc61eca62012-01-06 14:10:06 +0200893 filter = GL_NEAREST;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200894
895 n = texture_region(es, &repaint);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400896
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500897 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400898 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
899 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
900
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500901 v = ec->vertices.data;
902 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
903 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400904 glEnableVertexAttribArray(0);
905 glEnableVertexAttribArray(1);
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200906
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500907 glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
908
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200909 glDisableVertexAttribArray(1);
910 glDisableVertexAttribArray(0);
911
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500912 ec->vertices.size = 0;
913 ec->indices.size = 0;
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200914
915out:
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500916 pixman_region32_fini(&repaint);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500917}
918
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500919WL_EXPORT void
920weston_surface_restack(struct weston_surface *surface, struct wl_list *below)
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400921{
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500922 wl_list_remove(&surface->layer_link);
923 wl_list_insert(below, &surface->layer_link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500924 weston_surface_damage_below(surface);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500925 weston_surface_damage(surface);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400926}
927
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400928WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500929weston_compositor_damage_all(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400930{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500931 struct weston_output *output;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400932
933 wl_list_for_each(output, &compositor->output_list, link)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500934 weston_output_damage(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400935}
936
Kristian Høgsberg9f404b72012-01-26 00:11:01 -0500937WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500938weston_buffer_post_release(struct wl_buffer *buffer)
Benjamin Franzke06286262011-05-06 19:12:33 +0200939{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400940 if (--buffer->busy_count > 0)
Benjamin Franzke06286262011-05-06 19:12:33 +0200941 return;
Benjamin Franzke06286262011-05-06 19:12:33 +0200942
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400943 assert(buffer->resource.client != NULL);
Kristian Høgsbergeccef6a2011-11-17 16:46:19 -0500944 wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
Benjamin Franzke06286262011-05-06 19:12:33 +0200945}
946
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400947WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500948weston_output_damage(struct weston_output *output)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400949{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500950 struct weston_compositor *compositor = output->compositor;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400951
Kristian Høgsberg944236a2012-02-28 23:07:47 -0500952 pixman_region32_union(&compositor->damage,
953 &compositor->damage, &output->region);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500954 weston_compositor_schedule_repaint(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400955}
956
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400957static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500958fade_frame(struct weston_animation *animation,
959 struct weston_output *output, uint32_t msecs)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400960{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500961 struct weston_compositor *compositor =
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400962 container_of(animation,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500963 struct weston_compositor, fade.animation);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500964 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400965
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500966 surface = compositor->fade.surface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500967 weston_spring_update(&compositor->fade.spring, msecs);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500968 weston_surface_set_color(surface, 0.0, 0.0, 0.0,
969 compositor->fade.spring.current);
970 weston_surface_damage(surface);
971
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500972 if (weston_spring_done(&compositor->fade.spring)) {
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400973 compositor->fade.spring.current =
974 compositor->fade.spring.target;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400975 wl_list_remove(&animation->link);
976 wl_list_init(&animation->link);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200977
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500978 if (compositor->fade.spring.current < 0.001) {
979 destroy_surface(&surface->surface.resource);
980 compositor->fade.surface = NULL;
981 } else if (compositor->fade.spring.current > 0.999) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500982 compositor->state = WESTON_COMPOSITOR_SLEEPING;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -0400983 wl_signal_emit(&compositor->lock_signal, compositor);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200984 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400985 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400986}
987
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500988struct weston_frame_callback {
989 struct wl_resource resource;
990 struct wl_list link;
991};
992
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400993static void
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500994weston_output_repaint(struct weston_output *output, int msecs)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400995{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500996 struct weston_compositor *ec = output->compositor;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500997 struct weston_surface *es;
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500998 struct weston_layer *layer;
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500999 struct weston_animation *animation, *next;
1000 struct weston_frame_callback *cb, *cnext;
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001001 pixman_region32_t opaque, new_damage, output_damage;
Kristian Høgsberg546a8122012-02-01 07:45:51 -05001002 int32_t width, height;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001003
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001004 weston_compositor_update_drag_surfaces(ec);
1005
Kristian Høgsberg546a8122012-02-01 07:45:51 -05001006 width = output->current->width +
1007 output->border.left + output->border.right;
1008 height = output->current->height +
1009 output->border.top + output->border.bottom;
1010 glViewport(0, 0, width, height);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -05001011
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001012 /* Rebuild the surface list and update surface transforms up front. */
1013 wl_list_init(&ec->surface_list);
1014 wl_list_for_each(layer, &ec->layer_list, link) {
1015 wl_list_for_each(es, &layer->surface_list, layer_link) {
1016 weston_surface_update_transform(es);
1017 wl_list_insert(ec->surface_list.prev, &es->link);
1018 }
1019 }
Pekka Paalanen15d60ef2012-01-27 14:38:33 +02001020
Jesse Barnes5308a5e2012-02-09 13:12:57 -08001021 if (output->assign_planes)
1022 /*
1023 * This will queue flips for the fbs and sprites where
1024 * applicable and clear the damage for those surfaces.
1025 * The repaint loop below will repaint everything
1026 * else.
1027 */
1028 output->assign_planes(output);
1029
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001030 pixman_region32_init(&new_damage);
1031 pixman_region32_init(&opaque);
1032
Kristian Høgsberga82c4862012-01-26 01:03:58 -05001033 wl_list_for_each(es, &ec->surface_list, link) {
1034 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
1035 pixman_region32_union(&new_damage, &new_damage, &es->damage);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001036 empty_region(&es->damage);
1037 pixman_region32_copy(&es->clip, &opaque);
Pekka Paalanen730d87e2012-02-09 16:39:38 +02001038 pixman_region32_union(&opaque, &opaque, &es->transform.opaque);
Kristian Høgsberga82c4862012-01-26 01:03:58 -05001039 }
1040
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001041 pixman_region32_union(&ec->damage, &ec->damage, &new_damage);
1042
1043 pixman_region32_init(&output_damage);
1044 pixman_region32_union(&output_damage,
1045 &ec->damage, &output->previous_damage);
1046 pixman_region32_copy(&output->previous_damage, &ec->damage);
1047 pixman_region32_intersect(&output_damage,
1048 &output_damage, &output->region);
1049 pixman_region32_subtract(&ec->damage, &ec->damage, &output->region);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001050
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -04001051 pixman_region32_fini(&opaque);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -04001052 pixman_region32_fini(&new_damage);
1053
Scott Moreauccbf29d2012-02-22 14:21:41 -07001054 if (output->dirty)
1055 weston_output_update_matrix(output);
1056
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001057 output->repaint(output, &output_damage);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001058
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001059 pixman_region32_fini(&output_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001060
Kristian Høgsbergef044142011-06-21 15:02:12 -04001061 output->repaint_needed = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001062
Kristian Høgsbergaa6019e2012-03-11 16:35:16 -04001063 weston_compositor_repick(ec);
1064 wl_event_loop_dispatch(ec->input_loop, 0);
1065
Kristian Høgsberg33418202011-08-16 23:01:28 -04001066 wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) {
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05001067 wl_callback_send_done(&cb->resource, msecs);
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001068 wl_resource_destroy(&cb->resource);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001069 }
1070
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001071 wl_list_for_each_safe(animation, next, &ec->animation_list, link)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001072 animation->frame(animation, output, msecs);
1073}
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001074
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001075static int
1076weston_compositor_read_input(int fd, uint32_t mask, void *data)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001077{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001078 struct weston_compositor *compositor = data;
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05001079
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001080 wl_event_loop_dispatch(compositor->input_loop, 0);
1081
1082 return 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001083}
1084
1085WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001086weston_output_finish_frame(struct weston_output *output, int msecs)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001087{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001088 struct weston_compositor *compositor = output->compositor;
1089 struct wl_event_loop *loop =
1090 wl_display_get_event_loop(compositor->wl_display);
1091 int fd;
1092
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -04001093 wl_signal_emit(&output->frame_signal, &msecs);
1094
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001095 if (output->repaint_needed) {
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001096 weston_output_repaint(output, msecs);
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001097 return;
1098 }
1099
1100 output->repaint_scheduled = 0;
1101 if (compositor->input_loop_source)
1102 return;
1103
1104 fd = wl_event_loop_get_fd(compositor->input_loop);
1105 compositor->input_loop_source =
1106 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
1107 weston_compositor_read_input, compositor);
1108}
1109
1110static void
1111idle_repaint(void *data)
1112{
1113 struct weston_output *output = data;
1114
1115 weston_output_finish_frame(output, weston_compositor_get_time());
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001116}
1117
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001118WL_EXPORT void
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001119weston_layer_init(struct weston_layer *layer, struct wl_list *below)
1120{
1121 wl_list_init(&layer->surface_list);
1122 wl_list_insert(below, &layer->link);
1123}
1124
1125WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001126weston_compositor_schedule_repaint(struct weston_compositor *compositor)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001127{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001128 struct weston_output *output;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001129 struct wl_event_loop *loop;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001130
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001131 if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001132 return;
1133
Kristian Høgsbergef044142011-06-21 15:02:12 -04001134 loop = wl_display_get_event_loop(compositor->wl_display);
1135 wl_list_for_each(output, &compositor->output_list, link) {
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001136 output->repaint_needed = 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001137 if (output->repaint_scheduled)
1138 continue;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001139
Kristian Høgsbergef044142011-06-21 15:02:12 -04001140 wl_event_loop_add_idle(loop, idle_repaint, output);
1141 output->repaint_scheduled = 1;
1142 }
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001143
1144 if (compositor->input_loop_source) {
1145 wl_event_source_remove(compositor->input_loop_source);
1146 compositor->input_loop_source = NULL;
1147 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001148}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -05001149
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001150WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001151weston_compositor_fade(struct weston_compositor *compositor, float tint)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001152{
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001153 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001154 int done;
1155
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001156 done = weston_spring_done(&compositor->fade.spring);
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001157 compositor->fade.spring.target = tint;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001158 if (weston_spring_done(&compositor->fade.spring))
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001159 return;
1160
1161 if (done)
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001162 compositor->fade.spring.timestamp =
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001163 weston_compositor_get_time();
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001164
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001165 if (compositor->fade.surface == NULL) {
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001166 surface = weston_surface_create(compositor);
1167 weston_surface_configure(surface, 0, 0, 8192, 8192);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001168 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001169 wl_list_insert(&compositor->fade_layer.surface_list,
1170 &surface->layer_link);
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02001171 weston_surface_assign_output(surface);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001172 compositor->fade.surface = surface;
Kristian Høgsberg9bc70952012-02-29 12:22:38 -05001173 pixman_region32_init(&surface->input);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001174 }
1175
1176 weston_surface_damage(compositor->fade.surface);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001177 if (wl_list_empty(&compositor->fade.animation.link))
1178 wl_list_insert(compositor->animation_list.prev,
1179 &compositor->fade.animation.link);
1180}
1181
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001182static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001183surface_destroy(struct wl_client *client, struct wl_resource *resource)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001184{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001185 wl_resource_destroy(resource);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001186}
1187
Casey Dahlin96d8a752012-04-19 22:50:07 -04001188static struct wl_resource *
1189find_resource_for_client(struct wl_list *list, struct wl_client *client)
1190{
1191 struct wl_resource *r;
1192
1193 wl_list_for_each(r, list, link) {
1194 if (r->client == client)
1195 return r;
1196 }
1197
1198 return NULL;
1199}
1200
Casey Dahlin9074db52012-04-19 22:50:09 -04001201static void
1202weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask)
1203{
1204 uint32_t different = es->output_mask ^ mask;
1205 uint32_t entered = mask & different;
1206 uint32_t left = es->output_mask & different;
1207 struct weston_output *output;
Rob Bradford8667e772012-05-18 14:13:03 +01001208 struct wl_resource *resource = NULL;
Casey Dahlin9074db52012-04-19 22:50:09 -04001209 struct wl_client *client = es->surface.resource.client;
1210
1211 if (es->surface.resource.client == NULL)
1212 return;
1213 if (different == 0)
1214 return;
1215
1216 es->output_mask = mask;
1217 wl_list_for_each(output, &es->compositor->output_list, link) {
1218 if (1 << output->id & different)
1219 resource =
1220 find_resource_for_client(&output->resource_list,
1221 client);
1222 if (1 << output->id & entered)
1223 wl_surface_send_enter(&es->surface.resource, resource);
1224 if (1 << output->id & left)
1225 wl_surface_send_leave(&es->surface.resource, resource);
1226 }
1227}
1228
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001229WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001230weston_surface_assign_output(struct weston_surface *es)
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001231{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001232 struct weston_compositor *ec = es->compositor;
1233 struct weston_output *output, *new_output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001234 pixman_region32_t region;
Casey Dahlin9074db52012-04-19 22:50:09 -04001235 uint32_t max, area, mask;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001236 pixman_box32_t *e;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001237
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001238 new_output = NULL;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001239 max = 0;
Casey Dahlin9074db52012-04-19 22:50:09 -04001240 mask = 0;
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001241 pixman_region32_init(&region);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001242 wl_list_for_each(output, &ec->output_list, link) {
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001243 pixman_region32_intersect(&region, &es->transform.boundingbox,
1244 &output->region);
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001245
1246 e = pixman_region32_extents(&region);
1247 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1248
Casey Dahlin9074db52012-04-19 22:50:09 -04001249 if (area > 0)
1250 mask |= 1 << output->id;
1251
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001252 if (area >= max) {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001253 new_output = output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001254 max = area;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001255 }
1256 }
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001257 pixman_region32_fini(&region);
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001258
1259 es->output = new_output;
Casey Dahlin9074db52012-04-19 22:50:09 -04001260 weston_surface_update_output_mask(es, mask);
1261
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001262 if (!wl_list_empty(&es->frame_callback_list)) {
1263 wl_list_insert_list(new_output->frame_callback_list.prev,
1264 &es->frame_callback_list);
1265 wl_list_init(&es->frame_callback_list);
1266 }
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001267}
1268
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001269static void
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001270surface_attach(struct wl_client *client,
1271 struct wl_resource *resource,
1272 struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
1273{
1274 struct weston_surface *es = resource->data;
1275 struct wl_buffer *buffer = NULL;
1276
1277 if (buffer_resource)
1278 buffer = buffer_resource->data;
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001279
Kristian Høgsberg8cbfb2a2012-03-27 17:04:59 -04001280 weston_surface_attach(&es->surface, buffer);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001281
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03001282 if (buffer && es->configure)
1283 es->configure(es, sx, sy);
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001284}
1285
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001286static void
Pekka Paalanen52bfbaa2012-04-11 16:19:37 +03001287texture_set_subimage(struct weston_surface *surface,
1288 int32_t x, int32_t y, int32_t width, int32_t height)
1289{
1290 glBindTexture(GL_TEXTURE_2D, surface->texture);
1291
1292#ifdef GL_UNPACK_ROW_LENGTH
1293 /* Mesa does not define GL_EXT_unpack_subimage */
1294
1295 if (surface->compositor->has_unpack_subimage) {
1296 glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->pitch);
1297 glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
1298 glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
1299
1300 glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height,
1301 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1302 wl_shm_buffer_get_data(surface->buffer));
1303 return;
1304 }
1305#endif
1306
1307 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
1308 surface->pitch, surface->buffer->height, 0,
1309 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1310 wl_shm_buffer_get_data(surface->buffer));
1311}
1312
1313static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001314surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001315 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001316 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -05001317{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001318 struct weston_surface *es = resource->data;
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -04001319
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001320 weston_surface_damage_rectangle(es, x, y, width, height);
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04001321
Pekka Paalanen52bfbaa2012-04-11 16:19:37 +03001322 if (es->buffer && wl_buffer_is_shm(es->buffer))
1323 texture_set_subimage(es, x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001324}
1325
Kristian Høgsberg33418202011-08-16 23:01:28 -04001326static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001327destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001328{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001329 struct weston_frame_callback *cb = resource->data;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001330
1331 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02001332 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001333}
1334
1335static void
1336surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001337 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001338{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001339 struct weston_frame_callback *cb;
1340 struct weston_surface *es = resource->data;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001341
1342 cb = malloc(sizeof *cb);
1343 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001344 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001345 return;
1346 }
1347
1348 cb->resource.object.interface = &wl_callback_interface;
1349 cb->resource.object.id = callback;
1350 cb->resource.destroy = destroy_frame_callback;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001351 cb->resource.client = client;
1352 cb->resource.data = cb;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001353
1354 wl_client_add_resource(client, &cb->resource);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001355
1356 if (es->output) {
1357 wl_list_insert(es->output->frame_callback_list.prev,
1358 &cb->link);
1359 } else {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001360 wl_list_insert(es->frame_callback_list.prev, &cb->link);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001361 }
Kristian Høgsberg33418202011-08-16 23:01:28 -04001362}
1363
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001364static void
1365surface_set_opaque_region(struct wl_client *client,
1366 struct wl_resource *resource,
1367 struct wl_resource *region_resource)
1368{
1369 struct weston_surface *surface = resource->data;
1370 struct weston_region *region;
1371
1372 pixman_region32_fini(&surface->opaque);
1373
1374 if (region_resource) {
1375 region = region_resource->data;
1376 pixman_region32_init_rect(&surface->opaque, 0, 0,
1377 surface->geometry.width,
1378 surface->geometry.height);
1379 pixman_region32_intersect(&surface->opaque,
1380 &surface->opaque, &region->region);
1381 } else {
1382 pixman_region32_init(&surface->opaque);
1383 }
1384
1385 surface->geometry.dirty = 1;
1386}
1387
1388static void
1389surface_set_input_region(struct wl_client *client,
1390 struct wl_resource *resource,
1391 struct wl_resource *region_resource)
1392{
1393 struct weston_surface *surface = resource->data;
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05001394 struct weston_region *region;
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001395
1396 if (region_resource) {
1397 region = region_resource->data;
1398 pixman_region32_init_rect(&surface->input, 0, 0,
1399 surface->geometry.width,
1400 surface->geometry.height);
1401 pixman_region32_intersect(&surface->input,
1402 &surface->input, &region->region);
1403 } else {
1404 pixman_region32_init_rect(&surface->input, 0, 0,
1405 surface->geometry.width,
1406 surface->geometry.height);
1407 }
1408
Kristian Høgsbergaa6019e2012-03-11 16:35:16 -04001409 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001410}
1411
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001412static const struct wl_surface_interface surface_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001413 surface_destroy,
1414 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04001415 surface_damage,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001416 surface_frame,
1417 surface_set_opaque_region,
1418 surface_set_input_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001419};
1420
1421static void
1422compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001423 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001424{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001425 struct weston_compositor *ec = resource->data;
1426 struct weston_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001427
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001428 surface = weston_surface_create(ec);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001429 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001430 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001431 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001432 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001433
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001434 surface->surface.resource.destroy = destroy_surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001435
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001436 surface->surface.resource.object.id = id;
1437 surface->surface.resource.object.interface = &wl_surface_interface;
1438 surface->surface.resource.object.implementation =
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001439 (void (**)(void)) &surface_interface;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001440 surface->surface.resource.data = surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001441
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001442 wl_client_add_resource(client, &surface->surface.resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001443}
1444
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001445static void
1446destroy_region(struct wl_resource *resource)
1447{
1448 struct weston_region *region =
1449 container_of(resource, struct weston_region, resource);
1450
1451 pixman_region32_fini(&region->region);
1452 free(region);
1453}
1454
1455static void
1456region_destroy(struct wl_client *client, struct wl_resource *resource)
1457{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001458 wl_resource_destroy(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001459}
1460
1461static void
1462region_add(struct wl_client *client, struct wl_resource *resource,
1463 int32_t x, int32_t y, int32_t width, int32_t height)
1464{
1465 struct weston_region *region = resource->data;
1466
1467 pixman_region32_union_rect(&region->region, &region->region,
1468 x, y, width, height);
1469}
1470
1471static void
1472region_subtract(struct wl_client *client, struct wl_resource *resource,
1473 int32_t x, int32_t y, int32_t width, int32_t height)
1474{
1475 struct weston_region *region = resource->data;
1476 pixman_region32_t rect;
1477
1478 pixman_region32_init_rect(&rect, x, y, width, height);
1479 pixman_region32_subtract(&region->region, &region->region, &rect);
1480 pixman_region32_fini(&rect);
1481}
1482
1483static const struct wl_region_interface region_interface = {
1484 region_destroy,
1485 region_add,
1486 region_subtract
1487};
1488
1489static void
1490compositor_create_region(struct wl_client *client,
1491 struct wl_resource *resource, uint32_t id)
1492{
1493 struct weston_region *region;
1494
1495 region = malloc(sizeof *region);
1496 if (region == NULL) {
1497 wl_resource_post_no_memory(resource);
1498 return;
1499 }
1500
1501 region->resource.destroy = destroy_region;
1502
1503 region->resource.object.id = id;
1504 region->resource.object.interface = &wl_region_interface;
1505 region->resource.object.implementation =
1506 (void (**)(void)) &region_interface;
1507 region->resource.data = region;
1508
1509 pixman_region32_init(&region->region);
1510
1511 wl_client_add_resource(client, &region->resource);
1512}
1513
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001514static const struct wl_compositor_interface compositor_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001515 compositor_create_surface,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001516 compositor_create_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001517};
1518
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001519WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001520weston_compositor_wake(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001521{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001522 compositor->state = WESTON_COMPOSITOR_ACTIVE;
1523 weston_compositor_fade(compositor, 0.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001524
1525 wl_event_source_timer_update(compositor->idle_source,
Pekka Paalanen7296e792011-12-07 16:22:00 +02001526 compositor->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001527}
1528
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001529static void
1530weston_compositor_dpms_on(struct weston_compositor *compositor)
1531{
1532 struct weston_output *output;
1533
1534 wl_list_for_each(output, &compositor->output_list, link)
1535 if (output->set_dpms)
1536 output->set_dpms(output, WESTON_DPMS_ON);
1537}
1538
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001539WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001540weston_compositor_activity(struct weston_compositor *compositor)
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001541{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001542 if (compositor->state == WESTON_COMPOSITOR_ACTIVE) {
1543 weston_compositor_wake(compositor);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001544 } else {
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001545 weston_compositor_dpms_on(compositor);
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001546 wl_signal_emit(&compositor->unlock_signal, compositor);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001547 }
1548}
1549
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001550static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001551weston_compositor_idle_inhibit(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001552{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001553 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001554 compositor->idle_inhibit++;
1555}
1556
1557static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001558weston_compositor_idle_release(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001559{
1560 compositor->idle_inhibit--;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001561 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001562}
1563
1564static int
1565idle_handler(void *data)
1566{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001567 struct weston_compositor *compositor = data;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001568
1569 if (compositor->idle_inhibit)
1570 return 1;
1571
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001572 weston_compositor_fade(compositor, 1.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001573
1574 return 1;
1575}
1576
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001577static void
Daniel Stone37816df2012-05-16 18:45:18 +01001578weston_seat_update_drag_surface(struct wl_seat *seat, int dx, int dy);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001579
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001580static void
Daniel Stone37816df2012-05-16 18:45:18 +01001581clip_pointer_motion(struct weston_seat *seat, wl_fixed_t *fx, wl_fixed_t *fy)
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001582{
Daniel Stone37816df2012-05-16 18:45:18 +01001583 struct weston_compositor *ec = seat->compositor;
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001584 struct weston_output *output, *prev = NULL;
1585 int x, y, old_x, old_y, valid = 0;
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001586
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001587 x = wl_fixed_to_int(*fx);
1588 y = wl_fixed_to_int(*fy);
Daniel Stone37816df2012-05-16 18:45:18 +01001589 old_x = wl_fixed_to_int(seat->seat.pointer->x);
1590 old_y = wl_fixed_to_int(seat->seat.pointer->y);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001591
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001592 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001593 if (pixman_region32_contains_point(&output->region,
1594 x, y, NULL))
1595 valid = 1;
1596 if (pixman_region32_contains_point(&output->region,
1597 old_x, old_y, NULL))
1598 prev = output;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001599 }
Daniel Stone37816df2012-05-16 18:45:18 +01001600
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001601 if (!valid) {
1602 if (x < prev->x)
1603 *fx = wl_fixed_from_int(prev->x);
1604 else if (x >= prev->x + prev->current->width)
1605 *fx = wl_fixed_from_int(prev->x +
1606 prev->current->width - 1);
1607 if (y < prev->y)
1608 *fy = wl_fixed_from_int(prev->y);
1609 else if (y >= prev->y + prev->current->height)
1610 *fy = wl_fixed_from_int(prev->y +
1611 prev->current->height - 1);
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001612 }
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001613}
1614
1615WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001616notify_motion(struct wl_seat *seat, uint32_t time, wl_fixed_t x, wl_fixed_t y)
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001617{
1618 const struct wl_pointer_grab_interface *interface;
Daniel Stone37816df2012-05-16 18:45:18 +01001619 struct weston_seat *ws = (struct weston_seat *) seat;
1620 struct weston_compositor *ec = ws->compositor;
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001621 struct weston_output *output;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001622 int32_t ix, iy;
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001623
1624 weston_compositor_activity(ec);
1625
Daniel Stone37816df2012-05-16 18:45:18 +01001626 clip_pointer_motion(ws, &x, &y);
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001627
Daniel Stone37816df2012-05-16 18:45:18 +01001628 weston_seat_update_drag_surface(seat,
1629 x - seat->pointer->x,
1630 y - seat->pointer->y);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001631
Daniel Stone37816df2012-05-16 18:45:18 +01001632 seat->pointer->x = x;
1633 seat->pointer->y = y;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001634
1635 ix = wl_fixed_to_int(x);
1636 iy = wl_fixed_to_int(y);
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -05001637
Scott Moreauccbf29d2012-02-22 14:21:41 -07001638 wl_list_for_each(output, &ec->output_list, link)
1639 if (output->zoom.active &&
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001640 pixman_region32_contains_point(&output->region,
1641 ix, iy, NULL))
Scott Moreau7a1b32a2012-05-27 14:25:02 -06001642 weston_output_update_zoom(output, x, y, ZOOM_POINTER);
Scott Moreauccbf29d2012-02-22 14:21:41 -07001643
Daniel Stone37816df2012-05-16 18:45:18 +01001644 weston_device_repick(seat);
1645 interface = seat->pointer->grab->interface;
1646 interface->motion(seat->pointer->grab, time,
1647 seat->pointer->grab->x, seat->pointer->grab->y);
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001648
Daniel Stone37816df2012-05-16 18:45:18 +01001649 if (ws->sprite) {
1650 weston_surface_set_position(ws->sprite,
1651 ix - ws->hotspot_x,
1652 iy - ws->hotspot_y);
Pekka Paalanenf8c6aae2012-02-13 11:01:59 +02001653 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001654 }
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001655}
1656
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001657WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001658weston_surface_activate(struct weston_surface *surface,
Daniel Stone37816df2012-05-16 18:45:18 +01001659 struct weston_seat *seat)
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001660{
Daniel Stone37816df2012-05-16 18:45:18 +01001661 struct weston_compositor *compositor = seat->compositor;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001662
Daniel Stone37816df2012-05-16 18:45:18 +01001663 wl_keyboard_set_focus(seat->seat.keyboard, &surface->surface);
1664 wl_data_device_set_keyboard_focus(&seat->seat);
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001665
Daniel Stone351eb612012-05-31 15:27:47 -04001666 if (seat->seat.keyboard->focus_resource) {
1667 wl_keyboard_send_modifiers(seat->seat.keyboard->focus_resource,
1668 wl_display_next_serial(compositor->wl_display),
Daniel Stone994679a2012-05-30 16:31:43 +01001669 seat->xkb_state.mods_depressed,
1670 seat->xkb_state.mods_latched,
1671 seat->xkb_state.mods_locked,
1672 seat->xkb_state.group);
Daniel Stone351eb612012-05-31 15:27:47 -04001673 }
1674
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001675 wl_signal_emit(&compositor->activate_signal, surface);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001676}
1677
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001678WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001679notify_button(struct wl_seat *seat, uint32_t time, int32_t button,
Daniel Stone4dbadb12012-05-30 16:31:51 +01001680 enum wl_pointer_button_state state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001681{
Daniel Stone37816df2012-05-16 18:45:18 +01001682 struct weston_seat *ws = (struct weston_seat *) seat;
1683 struct weston_compositor *compositor = ws->compositor;
1684 struct weston_surface *focus =
1685 (struct weston_surface *) seat->pointer->focus;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001686 uint32_t serial = wl_display_next_serial(compositor->wl_display);
Kristian Høgsbergea081152010-12-07 08:59:51 -05001687
Daniel Stone4dbadb12012-05-30 16:31:51 +01001688 if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
Scott Moreauff1db4a2012-04-17 19:06:18 -06001689 if (compositor->ping_handler && focus)
1690 compositor->ping_handler(focus, serial);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001691 weston_compositor_idle_inhibit(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001692 if (seat->pointer->button_count == 0) {
1693 seat->pointer->grab_button = button;
1694 seat->pointer->grab_time = time;
1695 seat->pointer->grab_x = seat->pointer->x;
1696 seat->pointer->grab_y = seat->pointer->y;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001697 }
Daniel Stone37816df2012-05-16 18:45:18 +01001698 seat->pointer->button_count++;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001699 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001700 weston_compositor_idle_release(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001701 seat->pointer->button_count--;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001702 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001703
Daniel Stone325fc2d2012-05-30 16:31:58 +01001704 weston_compositor_run_button_binding(compositor, ws, time, button,
1705 state);
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001706
Daniel Stone37816df2012-05-16 18:45:18 +01001707 seat->pointer->grab->interface->button(seat->pointer->grab, time,
1708 button, state);
Kristian Høgsberg5a5f0072011-12-19 14:54:11 -05001709
Daniel Stone37816df2012-05-16 18:45:18 +01001710 if (seat->pointer->button_count == 1)
1711 seat->pointer->grab_serial =
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001712 wl_display_get_serial(compositor->wl_display);
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001713}
1714
Scott Moreau210d0792012-03-22 10:47:01 -06001715WL_EXPORT void
Daniel Stone878f0b72012-05-30 16:31:57 +01001716notify_axis(struct wl_seat *seat, uint32_t time, uint32_t axis,
1717 wl_fixed_t value)
Scott Moreau210d0792012-03-22 10:47:01 -06001718{
Daniel Stone37816df2012-05-16 18:45:18 +01001719 struct weston_seat *ws = (struct weston_seat *) seat;
1720 struct weston_compositor *compositor = ws->compositor;
1721 struct weston_surface *focus =
1722 (struct weston_surface *) seat->pointer->focus;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001723 uint32_t serial = wl_display_next_serial(compositor->wl_display);
1724
1725 if (compositor->ping_handler && focus)
1726 compositor->ping_handler(focus, serial);
Scott Moreau210d0792012-03-22 10:47:01 -06001727
1728 weston_compositor_activity(compositor);
1729
Scott Moreau6a3633d2012-03-20 08:47:59 -06001730 if (value)
Daniel Stone325fc2d2012-05-30 16:31:58 +01001731 weston_compositor_run_axis_binding(compositor, ws, time, axis,
Daniel Stone0c1e46e2012-05-30 16:31:59 +01001732 value);
Scott Moreau6a3633d2012-03-20 08:47:59 -06001733 else
1734 return;
1735
Daniel Stone37816df2012-05-16 18:45:18 +01001736 if (seat->pointer->focus_resource)
Daniel Stone878f0b72012-05-30 16:31:57 +01001737 wl_pointer_send_axis(seat->pointer->focus_resource, time, axis,
Daniel Stone2fce4022012-05-30 16:32:00 +01001738 value);
Scott Moreau210d0792012-03-22 10:47:01 -06001739}
1740
Daniel Stone7ace3902012-05-30 16:31:40 +01001741static int
Daniel Stone37816df2012-05-16 18:45:18 +01001742update_modifier_state(struct weston_seat *seat, uint32_t key, uint32_t state)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001743{
Daniel Stone7ace3902012-05-30 16:31:40 +01001744 uint32_t mods_depressed, mods_latched, mods_locked, group;
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001745 uint32_t mods_lookup;
Daniel Stone8c8164f2012-05-30 16:31:45 +01001746 enum weston_led leds = 0;
Daniel Stone7ace3902012-05-30 16:31:40 +01001747 int ret = 0;
1748
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001749 /* First update the XKB state object with the keypress. */
Daniel Stone994679a2012-05-30 16:31:43 +01001750 xkb_state_update_key(seat->xkb_state.state, key + 8,
Daniel Stone7ace3902012-05-30 16:31:40 +01001751 state ? XKB_KEY_DOWN : XKB_KEY_UP);
1752
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001753 /* Serialize and update our internal state, checking to see if it's
1754 * different to the previous state. */
Daniel Stone994679a2012-05-30 16:31:43 +01001755 mods_depressed = xkb_state_serialize_mods(seat->xkb_state.state,
1756 XKB_STATE_DEPRESSED);
1757 mods_latched = xkb_state_serialize_mods(seat->xkb_state.state,
1758 XKB_STATE_LATCHED);
1759 mods_locked = xkb_state_serialize_mods(seat->xkb_state.state,
1760 XKB_STATE_LOCKED);
1761 group = xkb_state_serialize_group(seat->xkb_state.state,
Daniel Stone7ace3902012-05-30 16:31:40 +01001762 XKB_STATE_EFFECTIVE);
1763
Daniel Stone994679a2012-05-30 16:31:43 +01001764 if (mods_depressed != seat->xkb_state.mods_depressed ||
1765 mods_latched != seat->xkb_state.mods_latched ||
1766 mods_locked != seat->xkb_state.mods_locked ||
1767 group != seat->xkb_state.group)
Daniel Stone7ace3902012-05-30 16:31:40 +01001768 ret = 1;
1769
Daniel Stone994679a2012-05-30 16:31:43 +01001770 seat->xkb_state.mods_depressed = mods_depressed;
1771 seat->xkb_state.mods_latched = mods_latched;
1772 seat->xkb_state.mods_locked = mods_locked;
1773 seat->xkb_state.group = group;
Kristian Høgsbergab909ae2001-01-01 22:24:24 -05001774
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001775 /* And update the modifier_state for bindings. */
1776 mods_lookup = mods_depressed | mods_latched;
1777 seat->modifier_state = 0;
Daniel Stone8db79692012-06-01 12:13:58 +01001778 if (mods_lookup & (1 << seat->xkb_info.ctrl_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001779 seat->modifier_state |= MODIFIER_CTRL;
Daniel Stone8db79692012-06-01 12:13:58 +01001780 if (mods_lookup & (1 << seat->xkb_info.alt_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001781 seat->modifier_state |= MODIFIER_ALT;
Daniel Stone8db79692012-06-01 12:13:58 +01001782 if (mods_lookup & (1 << seat->xkb_info.super_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001783 seat->modifier_state |= MODIFIER_SUPER;
Daniel Stone7ace3902012-05-30 16:31:40 +01001784
Daniel Stone8c8164f2012-05-30 16:31:45 +01001785 /* Finally, notify the compositor that LEDs have changed. */
1786 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001787 seat->xkb_info.num_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001788 leds |= LED_NUM_LOCK;
1789 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001790 seat->xkb_info.caps_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001791 leds |= LED_CAPS_LOCK;
1792 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001793 seat->xkb_info.scroll_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001794 leds |= LED_SCROLL_LOCK;
1795 if (leds != seat->xkb_state.leds && seat->led_update)
Daniel Stonebbf63bf2012-06-04 11:40:48 +01001796 seat->led_update(seat, leds);
Daniel Stone8c8164f2012-05-30 16:31:45 +01001797 seat->xkb_state.leds = leds;
1798
Daniel Stone7ace3902012-05-30 16:31:40 +01001799 return ret;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001800}
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001801
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001802WL_EXPORT void
Daniel Stonec9785ea2012-05-30 16:31:52 +01001803notify_key(struct wl_seat *seat, uint32_t time, uint32_t key,
1804 enum wl_keyboard_key_state state)
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001805{
Daniel Stone37816df2012-05-16 18:45:18 +01001806 struct weston_seat *ws = (struct weston_seat *) seat;
1807 struct weston_compositor *compositor = ws->compositor;
1808 struct weston_surface *focus =
1809 (struct weston_surface *) seat->pointer->focus;
Daniel Stone7ace3902012-05-30 16:31:40 +01001810 struct wl_keyboard_grab *grab = seat->keyboard->grab;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001811 uint32_t serial = wl_display_next_serial(compositor->wl_display);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001812 uint32_t *k, *end;
Daniel Stone7ace3902012-05-30 16:31:40 +01001813 int mods;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001814
Daniel Stonec9785ea2012-05-30 16:31:52 +01001815 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
Scott Moreauff1db4a2012-04-17 19:06:18 -06001816 if (compositor->ping_handler && focus)
1817 compositor->ping_handler(focus, serial);
1818
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001819 weston_compositor_idle_inhibit(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001820 seat->keyboard->grab_key = key;
1821 seat->keyboard->grab_time = time;
Scott Moreauec286eb2012-02-18 05:05:30 -07001822 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001823 weston_compositor_idle_release(compositor);
Scott Moreauec286eb2012-02-18 05:05:30 -07001824 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001825
Daniel Stone7ace3902012-05-30 16:31:40 +01001826 mods = update_modifier_state(ws, key, state);
Daniel Stone37816df2012-05-16 18:45:18 +01001827 end = seat->keyboard->keys.data + seat->keyboard->keys.size;
1828 for (k = seat->keyboard->keys.data; k < end; k++) {
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001829 if (*k == key)
1830 *k = *--end;
1831 }
Daniel Stone37816df2012-05-16 18:45:18 +01001832 seat->keyboard->keys.size = (void *) end - seat->keyboard->keys.data;
Daniel Stonec9785ea2012-05-30 16:31:52 +01001833 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
Daniel Stone37816df2012-05-16 18:45:18 +01001834 k = wl_array_add(&seat->keyboard->keys, sizeof *k);
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001835 *k = key;
1836 }
Ray Strodee96dcb82008-12-20 02:00:49 -05001837
Daniel Stone7ace3902012-05-30 16:31:40 +01001838 if (grab == &seat->keyboard->default_grab)
Daniel Stone325fc2d2012-05-30 16:31:58 +01001839 weston_compositor_run_key_binding(compositor, ws, time, key,
1840 state);
Kristian Høgsbergabcef3c2012-03-05 17:47:15 -05001841
Daniel Stone7ace3902012-05-30 16:31:40 +01001842 grab->interface->key(grab, time, key, state);
Daniel Stone351eb612012-05-31 15:27:47 -04001843 if (mods)
1844 grab->interface->modifiers(grab,
1845 wl_display_get_serial(compositor->wl_display),
Daniel Stone994679a2012-05-30 16:31:43 +01001846 ws->xkb_state.mods_depressed,
1847 ws->xkb_state.mods_latched,
1848 ws->xkb_state.mods_locked,
1849 ws->xkb_state.group);
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001850}
1851
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001852WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001853notify_pointer_focus(struct wl_seat *seat, struct weston_output *output,
1854 wl_fixed_t x, wl_fixed_t y)
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001855{
Daniel Stone37816df2012-05-16 18:45:18 +01001856 struct weston_seat *ws = (struct weston_seat *) seat;
1857 struct weston_compositor *compositor = ws->compositor;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001858
1859 if (output) {
Daniel Stone37816df2012-05-16 18:45:18 +01001860 weston_seat_update_drag_surface(seat,
1861 x - seat->pointer->x,
1862 y - seat->pointer->y);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001863
Daniel Stone37816df2012-05-16 18:45:18 +01001864 seat->pointer->x = x;
1865 seat->pointer->y = y;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001866 compositor->focus = 1;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001867 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001868 } else {
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001869 compositor->focus = 0;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001870 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001871 }
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001872}
1873
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001874static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001875destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001876{
Daniel Stone37816df2012-05-16 18:45:18 +01001877 struct weston_seat *ws;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001878
Daniel Stone37816df2012-05-16 18:45:18 +01001879 ws = container_of(listener, struct weston_seat,
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001880 saved_kbd_focus_listener);
1881
Daniel Stone37816df2012-05-16 18:45:18 +01001882 ws->saved_kbd_focus = NULL;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001883}
1884
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001885WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001886notify_keyboard_focus(struct wl_seat *seat, struct wl_array *keys)
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001887{
Daniel Stone37816df2012-05-16 18:45:18 +01001888 struct weston_seat *ws = (struct weston_seat *) seat;
1889 struct weston_compositor *compositor = ws->compositor;
Kristian Høgsbergafee2212012-03-20 17:28:20 -04001890 struct wl_surface *surface;
Kristian Høgsbergd3c02752012-03-04 22:35:47 -05001891 uint32_t *k;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001892
Kristian Høgsberg31dd6b82012-04-09 22:10:00 -04001893 if (keys) {
Daniel Stone37816df2012-05-16 18:45:18 +01001894 wl_array_copy(&seat->keyboard->keys, keys);
1895 ws->modifier_state = 0;
1896 wl_array_for_each(k, &seat->keyboard->keys) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001897 weston_compositor_idle_inhibit(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001898 update_modifier_state(ws, *k, 1);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001899 }
1900
Daniel Stone37816df2012-05-16 18:45:18 +01001901 surface = ws->saved_kbd_focus;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001902
Kristian Høgsbergafee2212012-03-20 17:28:20 -04001903 if (surface) {
Daniel Stone37816df2012-05-16 18:45:18 +01001904 wl_list_remove(&ws->saved_kbd_focus_listener.link);
1905 wl_keyboard_set_focus(ws->seat.keyboard, surface);
Daniel Stone351eb612012-05-31 15:27:47 -04001906
1907 if (seat->keyboard->focus_resource) {
1908 wl_keyboard_send_modifiers(seat->keyboard->focus_resource,
1909 wl_display_next_serial(compositor->wl_display),
Daniel Stone994679a2012-05-30 16:31:43 +01001910 ws->xkb_state.mods_depressed,
1911 ws->xkb_state.mods_latched,
1912 ws->xkb_state.mods_locked,
1913 ws->xkb_state.group);
Daniel Stone351eb612012-05-31 15:27:47 -04001914 }
Daniel Stone37816df2012-05-16 18:45:18 +01001915 ws->saved_kbd_focus = NULL;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001916 }
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001917 } else {
Daniel Stone37816df2012-05-16 18:45:18 +01001918 wl_array_for_each(k, &seat->keyboard->keys)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001919 weston_compositor_idle_release(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001920
Daniel Stone37816df2012-05-16 18:45:18 +01001921 ws->modifier_state = 0;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001922
Daniel Stone37816df2012-05-16 18:45:18 +01001923 surface = ws->seat.keyboard->focus;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001924
Kristian Høgsbergafee2212012-03-20 17:28:20 -04001925 if (surface) {
Daniel Stone37816df2012-05-16 18:45:18 +01001926 ws->saved_kbd_focus = surface;
1927 ws->saved_kbd_focus_listener.notify =
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001928 destroy_device_saved_kbd_focus;
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001929 wl_signal_add(&surface->resource.destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01001930 &ws->saved_kbd_focus_listener);
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001931 }
1932
Daniel Stone37816df2012-05-16 18:45:18 +01001933 wl_keyboard_set_focus(ws->seat.keyboard, NULL);
Kristian Høgsberg035dd9c2012-04-10 00:33:40 -04001934 /* FIXME: We really need keyboard grab cancel here to
1935 * let the grab shut down properly. As it is we leak
1936 * the grab data. */
Daniel Stone37816df2012-05-16 18:45:18 +01001937 wl_keyboard_end_grab(ws->seat.keyboard);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001938 }
1939}
1940
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001941static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001942lose_touch_focus_resource(struct wl_listener *listener, void *data)
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001943{
Daniel Stone37816df2012-05-16 18:45:18 +01001944 struct weston_seat *seat = container_of(listener, struct weston_seat,
1945 touch_focus_resource_listener);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001946
Daniel Stone37816df2012-05-16 18:45:18 +01001947 seat->touch_focus_resource = NULL;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001948}
1949
1950static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001951lose_touch_focus(struct wl_listener *listener, void *data)
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001952{
Daniel Stone37816df2012-05-16 18:45:18 +01001953 struct weston_seat *seat = container_of(listener, struct weston_seat,
1954 touch_focus_listener);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001955
Daniel Stone37816df2012-05-16 18:45:18 +01001956 seat->touch_focus = NULL;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001957}
1958
1959static void
Daniel Stone37816df2012-05-16 18:45:18 +01001960touch_set_focus(struct weston_seat *ws, struct wl_surface *surface)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001961{
Daniel Stone37816df2012-05-16 18:45:18 +01001962 struct wl_seat *seat = &ws->seat;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001963 struct wl_resource *resource;
1964
Daniel Stone37816df2012-05-16 18:45:18 +01001965 if (ws->touch_focus == surface)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001966 return;
1967
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001968 if (surface) {
1969 resource =
Daniel Stone37816df2012-05-16 18:45:18 +01001970 find_resource_for_client(&seat->touch->resource_list,
Casey Dahlin96d8a752012-04-19 22:50:07 -04001971 surface->resource.client);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001972 if (!resource) {
1973 fprintf(stderr, "couldn't find resource\n");
1974 return;
1975 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001976
Daniel Stone37816df2012-05-16 18:45:18 +01001977 ws->touch_focus_resource_listener.notify =
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001978 lose_touch_focus_resource;
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001979 wl_signal_add(&resource->destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01001980 &ws->touch_focus_resource_listener);
1981 ws->touch_focus_listener.notify = lose_touch_focus;
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001982 wl_signal_add(&surface->resource.destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01001983 &ws->touch_focus_listener);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001984
Daniel Stone37816df2012-05-16 18:45:18 +01001985 seat->touch->focus = surface;
1986 seat->touch->focus_resource = resource;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001987 } else {
Daniel Stone37816df2012-05-16 18:45:18 +01001988 if (seat->touch->focus)
1989 wl_list_remove(&ws->touch_focus_listener.link);
1990 if (seat->touch->focus_resource)
1991 wl_list_remove(&ws->touch_focus_resource_listener.link);
1992 seat->touch->focus = NULL;
1993 seat->touch->focus_resource = NULL;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001994 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001995}
1996
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001997/**
1998 * notify_touch - emulates button touches and notifies surfaces accordingly.
1999 *
2000 * It assumes always the correct cycle sequence until it gets here: touch_down
2001 * → touch_update → ... → touch_update → touch_end. The driver is responsible
2002 * for sending along such order.
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002003 *
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002004 */
2005WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01002006notify_touch(struct wl_seat *seat, uint32_t time, int touch_id,
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002007 wl_fixed_t x, wl_fixed_t y, int touch_type)
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002008{
Daniel Stone37816df2012-05-16 18:45:18 +01002009 struct weston_seat *ws = (struct weston_seat *) seat;
2010 struct weston_compositor *ec = ws->compositor;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002011 struct weston_surface *es;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002012 wl_fixed_t sx, sy;
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04002013 uint32_t serial = 0;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002014
2015 switch (touch_type) {
Daniel Stone37816df2012-05-16 18:45:18 +01002016 case WL_TOUCH_DOWN:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002017 weston_compositor_idle_inhibit(ec);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002018
Daniel Stone37816df2012-05-16 18:45:18 +01002019 ws->num_tp++;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002020
2021 /* the first finger down picks the surface, and all further go
2022 * to that surface for the remainder of the touch session i.e.
2023 * until all touch points are up again. */
Daniel Stone37816df2012-05-16 18:45:18 +01002024 if (ws->num_tp == 1) {
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002025 es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
Daniel Stone37816df2012-05-16 18:45:18 +01002026 touch_set_focus(ws, &es->surface);
2027 } else if (ws->touch_focus) {
2028 es = (struct weston_surface *) ws->touch_focus;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002029 weston_surface_from_global_fixed(es, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002030 }
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002031
Daniel Stone37816df2012-05-16 18:45:18 +01002032 if (ws->touch_focus_resource && ws->touch_focus)
2033 wl_touch_send_down(ws->touch_focus_resource,
2034 serial, time,
2035 &ws->touch_focus->resource,
2036 touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002037 break;
Daniel Stone37816df2012-05-16 18:45:18 +01002038 case WL_TOUCH_MOTION:
2039 es = (struct weston_surface *) ws->touch_focus;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002040 if (!es)
2041 break;
2042
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002043 weston_surface_from_global_fixed(es, x, y, &sx, &sy);
Daniel Stone37816df2012-05-16 18:45:18 +01002044 if (ws->touch_focus_resource)
2045 wl_touch_send_motion(ws->touch_focus_resource,
2046 time, touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002047 break;
Daniel Stone37816df2012-05-16 18:45:18 +01002048 case WL_TOUCH_UP:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002049 weston_compositor_idle_release(ec);
Daniel Stone37816df2012-05-16 18:45:18 +01002050 ws->num_tp--;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002051
Daniel Stone37816df2012-05-16 18:45:18 +01002052 if (ws->touch_focus_resource)
2053 wl_touch_send_up(ws->touch_focus_resource,
2054 serial, time, touch_id);
2055 if (ws->num_tp == 0)
2056 touch_set_focus(ws, NULL);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002057 break;
2058 }
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002059}
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05002060
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04002061static void
Daniel Stone37816df2012-05-16 18:45:18 +01002062pointer_attach(struct wl_client *client, struct wl_resource *resource,
2063 uint32_t serial, struct wl_resource *buffer_resource,
2064 int32_t x, int32_t y)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002065{
Daniel Stone37816df2012-05-16 18:45:18 +01002066 struct weston_seat *seat = resource->data;
2067 struct weston_compositor *compositor = seat->compositor;
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03002068 struct wl_buffer *buffer = NULL;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002069
Daniel Stone37816df2012-05-16 18:45:18 +01002070 if (serial < seat->seat.pointer->focus_serial)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002071 return;
Daniel Stone37816df2012-05-16 18:45:18 +01002072 if (seat->seat.pointer->focus == NULL)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002073 return;
Daniel Stone37816df2012-05-16 18:45:18 +01002074 if (seat->seat.pointer->focus->resource.client != client)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002075 return;
2076
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03002077 if (buffer_resource)
2078 buffer = buffer_resource->data;
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04002079
Daniel Stone37816df2012-05-16 18:45:18 +01002080 weston_surface_attach(&seat->sprite->surface, buffer);
2081 empty_region(&seat->sprite->input);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03002082
2083 if (!buffer)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002084 return;
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05002085
Daniel Stone37816df2012-05-16 18:45:18 +01002086 if (!weston_surface_is_mapped(seat->sprite)) {
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05002087 wl_list_insert(&compositor->cursor_layer.surface_list,
Daniel Stone37816df2012-05-16 18:45:18 +01002088 &seat->sprite->layer_link);
2089 weston_surface_assign_output(seat->sprite);
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02002090 }
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05002091
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03002092
Daniel Stone37816df2012-05-16 18:45:18 +01002093 seat->hotspot_x = x;
2094 seat->hotspot_y = y;
2095 weston_surface_configure(seat->sprite,
2096 wl_fixed_to_int(seat->seat.pointer->x) - x,
2097 wl_fixed_to_int(seat->seat.pointer->y) - y,
Kristian Høgsberg18c93002012-01-27 11:58:31 -05002098 buffer->width, buffer->height);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05002099
Daniel Stone37816df2012-05-16 18:45:18 +01002100 surface_damage(NULL, &seat->sprite->surface.resource,
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04002101 0, 0, buffer->width, buffer->height);
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002102}
2103
Daniel Stone37816df2012-05-16 18:45:18 +01002104static const struct wl_pointer_interface pointer_interface = {
2105 pointer_attach,
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002106};
2107
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002108static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002109handle_drag_surface_destroy(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002110{
Daniel Stone37816df2012-05-16 18:45:18 +01002111 struct weston_seat *seat;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002112
Daniel Stone37816df2012-05-16 18:45:18 +01002113 seat = container_of(listener, struct weston_seat,
2114 drag_surface_destroy_listener);
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002115
Daniel Stone37816df2012-05-16 18:45:18 +01002116 seat->drag_surface = NULL;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002117}
2118
Casey Dahlin9074db52012-04-19 22:50:09 -04002119static void unbind_resource(struct wl_resource *resource)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04002120{
2121 wl_list_remove(&resource->link);
2122 free(resource);
2123}
2124
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002125static void
Daniel Stone37816df2012-05-16 18:45:18 +01002126seat_get_pointer(struct wl_client *client, struct wl_resource *resource,
2127 uint32_t id)
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002128{
Daniel Stone37816df2012-05-16 18:45:18 +01002129 struct weston_seat *seat = resource->data;
2130 struct wl_resource *cr;
Kristian Høgsberg8e6d7122011-08-29 16:04:39 -04002131
Daniel Stone37816df2012-05-16 18:45:18 +01002132 if (!seat->seat.pointer)
2133 return;
2134
2135 cr = wl_client_add_object(client, &wl_pointer_interface,
2136 &pointer_interface, id, seat);
2137 wl_list_insert(&seat->seat.pointer->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002138 cr->destroy = unbind_resource;
Daniel Stone17b13bd2012-05-30 16:31:39 +01002139
2140 if (seat->seat.pointer->focus &&
2141 seat->seat.pointer->focus->resource.client == client) {
2142 struct weston_surface *surface;
2143 wl_fixed_t sx, sy;
2144
2145 surface = (struct weston_surface *) seat->seat.pointer->focus;
2146 weston_surface_from_global_fixed(surface,
2147 seat->seat.pointer->x,
2148 seat->seat.pointer->y,
2149 &sx,
2150 &sy);
2151 wl_pointer_set_focus(seat->seat.pointer,
2152 seat->seat.pointer->focus,
2153 sx,
2154 sy);
2155 }
Daniel Stone37816df2012-05-16 18:45:18 +01002156}
2157
2158static void
2159seat_get_keyboard(struct wl_client *client, struct wl_resource *resource,
2160 uint32_t id)
2161{
2162 struct weston_seat *seat = resource->data;
2163 struct wl_resource *cr;
2164
2165 if (!seat->seat.keyboard)
2166 return;
2167
2168 cr = wl_client_add_object(client, &wl_keyboard_interface, NULL, id,
2169 seat);
2170 wl_list_insert(&seat->seat.keyboard->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002171 cr->destroy = unbind_resource;
Daniel Stone17b13bd2012-05-30 16:31:39 +01002172
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002173 wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
2174 seat->xkb_info.keymap_fd,
2175 seat->xkb_info.keymap_size);
2176
Daniel Stone17b13bd2012-05-30 16:31:39 +01002177 if (seat->seat.keyboard->focus &&
2178 seat->seat.keyboard->focus->resource.client == client) {
2179 wl_keyboard_set_focus(seat->seat.keyboard,
2180 seat->seat.keyboard->focus);
2181 }
Daniel Stone37816df2012-05-16 18:45:18 +01002182}
2183
2184static void
2185seat_get_touch(struct wl_client *client, struct wl_resource *resource,
2186 uint32_t id)
2187{
2188 struct weston_seat *seat = resource->data;
2189 struct wl_resource *cr;
2190
2191 if (!seat->seat.touch)
2192 return;
2193
2194 cr = wl_client_add_object(client, &wl_touch_interface, NULL, id, seat);
2195 wl_list_insert(&seat->seat.touch->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002196 cr->destroy = unbind_resource;
Daniel Stone37816df2012-05-16 18:45:18 +01002197}
2198
2199static const struct wl_seat_interface seat_interface = {
2200 seat_get_pointer,
2201 seat_get_keyboard,
2202 seat_get_touch,
2203};
2204
2205static void
2206bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id)
2207{
2208 struct wl_seat *seat = data;
2209 struct wl_resource *resource;
2210 enum wl_seat_capability caps = 0;
2211
2212 resource = wl_client_add_object(client, &wl_seat_interface,
2213 &seat_interface, id, data);
2214 wl_list_insert(&seat->base_resource_list, &resource->link);
Casey Dahlin9074db52012-04-19 22:50:09 -04002215 resource->destroy = unbind_resource;
Daniel Stone37816df2012-05-16 18:45:18 +01002216
2217 if (seat->pointer)
2218 caps |= WL_SEAT_CAPABILITY_POINTER;
2219 if (seat->keyboard)
2220 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
2221 if (seat->touch)
2222 caps |= WL_SEAT_CAPABILITY_TOUCH;
2223
2224 wl_seat_send_capabilities(resource, caps);
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002225}
2226
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002227static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002228device_handle_new_drag_icon(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002229{
Daniel Stone37816df2012-05-16 18:45:18 +01002230 struct weston_seat *seat;
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002231
Daniel Stone37816df2012-05-16 18:45:18 +01002232 seat = container_of(listener, struct weston_seat,
2233 new_drag_icon_listener);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002234
Daniel Stone37816df2012-05-16 18:45:18 +01002235 weston_seat_update_drag_surface(&seat->seat, 0, 0);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002236}
2237
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002238static void weston_compositor_xkb_init(struct weston_compositor *ec,
2239 struct xkb_rule_names *names)
Daniel Stone994679a2012-05-30 16:31:43 +01002240{
Daniel Stonee379da92012-05-30 16:32:04 +01002241 if (ec->xkb_context == NULL) {
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002242 ec->xkb_context = xkb_context_new(0);
2243 if (ec->xkb_context == NULL) {
2244 fprintf(stderr, "failed to create XKB context\n");
2245 exit(1);
2246 }
Daniel Stone994679a2012-05-30 16:31:43 +01002247 }
2248
2249 if (names)
Daniel Stonee379da92012-05-30 16:32:04 +01002250 ec->xkb_names = *names;
2251 if (!ec->xkb_names.rules)
2252 ec->xkb_names.rules = strdup("evdev");
2253 if (!ec->xkb_names.model)
2254 ec->xkb_names.model = strdup("pc105");
2255 if (!ec->xkb_names.layout)
2256 ec->xkb_names.layout = strdup("us");
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002257}
2258
Daniel Stonee379da92012-05-30 16:32:04 +01002259static void xkb_info_destroy(struct weston_xkb_info *xkb_info)
2260{
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002261 if (xkb_info->keymap)
2262 xkb_map_unref(xkb_info->keymap);
2263
2264 if (xkb_info->keymap_area)
2265 munmap(xkb_info->keymap_area, xkb_info->keymap_size);
2266 if (xkb_info->keymap_fd >= 0)
2267 close(xkb_info->keymap_fd);
Daniel Stonee379da92012-05-30 16:32:04 +01002268}
2269
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002270static void weston_compositor_xkb_destroy(struct weston_compositor *ec)
2271{
Daniel Stonee379da92012-05-30 16:32:04 +01002272 free((char *) ec->xkb_names.rules);
2273 free((char *) ec->xkb_names.model);
2274 free((char *) ec->xkb_names.layout);
2275 free((char *) ec->xkb_names.variant);
2276 free((char *) ec->xkb_names.options);
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002277
Daniel Stonee379da92012-05-30 16:32:04 +01002278 xkb_info_destroy(&ec->xkb_info);
2279 xkb_context_unref(ec->xkb_context);
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002280}
2281
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002282static void
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002283weston_xkb_info_new_keymap(struct weston_xkb_info *xkb_info)
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002284{
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002285 char *keymap_str;
2286 char *path;
2287
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002288 xkb_info->ctrl_mod = xkb_map_mod_get_index(xkb_info->keymap,
2289 XKB_MOD_NAME_CTRL);
2290 xkb_info->alt_mod = xkb_map_mod_get_index(xkb_info->keymap,
2291 XKB_MOD_NAME_ALT);
2292 xkb_info->super_mod = xkb_map_mod_get_index(xkb_info->keymap,
2293 XKB_MOD_NAME_LOGO);
2294
2295 xkb_info->num_led = xkb_map_led_get_index(xkb_info->keymap,
2296 XKB_LED_NAME_NUM);
2297 xkb_info->caps_led = xkb_map_led_get_index(xkb_info->keymap,
2298 XKB_LED_NAME_CAPS);
2299 xkb_info->scroll_led = xkb_map_led_get_index(xkb_info->keymap,
2300 XKB_LED_NAME_SCROLL);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002301
2302 keymap_str = xkb_map_get_as_string(xkb_info->keymap);
2303 if (keymap_str == NULL) {
2304 fprintf(stderr, "failed to get string version of keymap\n");
2305 exit(EXIT_FAILURE);
2306 }
2307 xkb_info->keymap_size = strlen(keymap_str) + 1;
2308
2309 /* Create a temporary file in /dev/shm to use for mapping the keymap,
2310 * and then unlink it as soon as we can. */
2311 path = strdup("/dev/shm/weston-keymap-XXXXXX");
2312 if (path == NULL) {
2313 fprintf(stderr, "failed to allocate keymap path\n");
2314 goto err_keymap_str;
2315 }
2316
2317 xkb_info->keymap_fd = mkostemp(path, O_CLOEXEC);
2318 if (xkb_info->keymap_fd < 0) {
2319 fprintf(stderr, "failed to create temporary keymap file\n");
2320 goto err_path;
2321 }
2322 unlink(path);
2323
2324 if (ftruncate(xkb_info->keymap_fd, xkb_info->keymap_size) != 0) {
2325 fprintf(stderr, "failed to enlarage temporary keymap file\n");
2326 goto err_path;
2327 }
2328
2329 xkb_info->keymap_area = mmap(NULL, xkb_info->keymap_size,
2330 PROT_READ | PROT_WRITE,
2331 MAP_SHARED, xkb_info->keymap_fd, 0);
2332 if (xkb_info->keymap_area == MAP_FAILED) {
2333 fprintf(stderr, "failed to mmap() %lu bytes on %s\n",
2334 (unsigned long) xkb_info->keymap_size,
2335 path);
2336 goto err_dev_zero;
2337 }
2338 strcpy(xkb_info->keymap_area, keymap_str);
2339 free(keymap_str);
2340 free(path);
2341
2342 return;
2343
2344err_dev_zero:
2345 close(xkb_info->keymap_fd);
2346 xkb_info->keymap_fd = -1;
2347err_path:
2348 free(path);
2349err_keymap_str:
2350 free(keymap_str);
2351 exit(EXIT_FAILURE);
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002352}
2353
2354static void
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002355weston_compositor_build_global_keymap(struct weston_compositor *ec)
2356{
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002357 if (ec->xkb_info.keymap != NULL)
2358 return;
2359
Daniel Stonee379da92012-05-30 16:32:04 +01002360 ec->xkb_info.keymap = xkb_map_new_from_names(ec->xkb_context,
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002361 &ec->xkb_names,
2362 0);
Daniel Stone994679a2012-05-30 16:31:43 +01002363 if (ec->xkb_info.keymap == NULL) {
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002364 fprintf(stderr, "failed to compile global XKB keymap\n");
2365 fprintf(stderr,
2366 " tried rules %s, model %s, layout %s, variant %s, "
2367 "options %s",
2368 ec->xkb_names.rules, ec->xkb_names.model,
2369 ec->xkb_names.layout, ec->xkb_names.variant,
2370 ec->xkb_names.options);
2371 exit(1);
Daniel Stone994679a2012-05-30 16:31:43 +01002372 }
2373
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002374 weston_xkb_info_new_keymap(&ec->xkb_info);
Daniel Stone994679a2012-05-30 16:31:43 +01002375}
2376
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002377WL_EXPORT void
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002378weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap)
Daniel Stone994679a2012-05-30 16:31:43 +01002379{
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002380 if (seat->has_keyboard)
2381 return;
Daniel Stone994679a2012-05-30 16:31:43 +01002382
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002383 if (keymap != NULL) {
2384 seat->xkb_info.keymap = xkb_map_ref(keymap);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002385 weston_xkb_info_new_keymap(&seat->xkb_info);
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002386 }
2387 else {
2388 weston_compositor_build_global_keymap(seat->compositor);
2389 seat->xkb_info = seat->compositor->xkb_info;
2390 seat->xkb_info.keymap = xkb_map_ref(seat->xkb_info.keymap);
2391 }
Daniel Stoned65b9092012-05-30 16:32:05 +01002392
2393 seat->xkb_state.state = xkb_state_new(seat->xkb_info.keymap);
2394 if (seat->xkb_state.state == NULL) {
2395 fprintf(stderr, "failed to initialise XKB state\n");
2396 exit(1);
2397 }
2398
2399 seat->xkb_state.mods_depressed = 0;
2400 seat->xkb_state.mods_latched = 0;
2401 seat->xkb_state.mods_locked = 0;
2402 seat->xkb_state.group = 0;
2403
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002404 wl_keyboard_init(&seat->keyboard);
2405 wl_seat_set_keyboard(&seat->seat, &seat->keyboard);
2406
2407 seat->has_keyboard = 1;
Daniel Stone994679a2012-05-30 16:31:43 +01002408}
2409
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002410WL_EXPORT void
Daniel Stone74419a22012-05-30 16:32:02 +01002411weston_seat_init_pointer(struct weston_seat *seat)
2412{
2413 if (seat->has_pointer)
2414 return;
2415
2416 wl_pointer_init(&seat->pointer);
2417 wl_seat_set_pointer(&seat->seat, &seat->pointer);
2418
2419 seat->has_pointer = 1;
2420}
2421
2422WL_EXPORT void
Daniel Stone74419a22012-05-30 16:32:02 +01002423weston_seat_init_touch(struct weston_seat *seat)
2424{
2425 if (seat->has_touch)
2426 return;
2427
2428 wl_touch_init(&seat->touch);
2429 wl_seat_set_touch(&seat->seat, &seat->touch);
2430
2431 seat->has_touch = 1;
2432}
2433
2434WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01002435weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05002436{
Daniel Stone37816df2012-05-16 18:45:18 +01002437 wl_seat_init(&seat->seat);
Daniel Stone74419a22012-05-30 16:32:02 +01002438 seat->has_pointer = 0;
2439 seat->has_keyboard = 0;
2440 seat->has_touch = 0;
Kristian Høgsberg02ef1c12010-12-06 21:35:19 -05002441
Daniel Stone37816df2012-05-16 18:45:18 +01002442 wl_display_add_global(ec->wl_display, &wl_seat_interface, seat,
2443 bind_seat);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04002444
Daniel Stone37816df2012-05-16 18:45:18 +01002445 seat->sprite = weston_surface_create(ec);
2446 seat->sprite->surface.resource.data = seat->sprite;
Kristian Høgsberg8244b442011-06-23 15:44:14 -04002447
Daniel Stone37816df2012-05-16 18:45:18 +01002448 seat->compositor = ec;
2449 seat->hotspot_x = 16;
2450 seat->hotspot_y = 16;
2451 seat->modifier_state = 0;
2452 seat->num_tp = 0;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05002453
Daniel Stone37816df2012-05-16 18:45:18 +01002454 seat->drag_surface_destroy_listener.notify =
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002455 handle_drag_surface_destroy;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002456
Daniel Stone37816df2012-05-16 18:45:18 +01002457 wl_list_insert(ec->seat_list.prev, &seat->link);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002458
Daniel Stone37816df2012-05-16 18:45:18 +01002459 seat->new_drag_icon_listener.notify = device_handle_new_drag_icon;
2460 wl_signal_add(&seat->seat.drag_icon_signal,
2461 &seat->new_drag_icon_listener);
Kristian Høgsberga7ceaff2012-06-03 10:20:13 -04002462
2463 clipboard_create(seat);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05002464}
2465
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002466WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01002467weston_seat_release(struct weston_seat *seat)
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002468{
Daniel Stone37816df2012-05-16 18:45:18 +01002469 wl_list_remove(&seat->link);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002470 /* The global object is destroyed at wl_display_destroy() time. */
2471
Daniel Stone37816df2012-05-16 18:45:18 +01002472 if (seat->sprite)
2473 destroy_surface(&seat->sprite->surface.resource);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002474
Daniel Stone74419a22012-05-30 16:32:02 +01002475 if (seat->xkb_state.state != NULL)
2476 xkb_state_unref(seat->xkb_state.state);
Daniel Stoned65b9092012-05-30 16:32:05 +01002477 xkb_info_destroy(&seat->xkb_info);
Daniel Stone994679a2012-05-30 16:31:43 +01002478
Daniel Stone37816df2012-05-16 18:45:18 +01002479 wl_seat_release(&seat->seat);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002480}
2481
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002482static void
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002483drag_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
2484{
2485 weston_surface_configure(es,
2486 es->geometry.x + sx, es->geometry.y + sy,
2487 es->buffer->width, es->buffer->height);
2488}
2489
2490static int
Daniel Stone37816df2012-05-16 18:45:18 +01002491device_setup_new_drag_surface(struct weston_seat *ws,
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002492 struct weston_surface *surface)
2493{
Daniel Stone37816df2012-05-16 18:45:18 +01002494 struct wl_seat *seat = &ws->seat;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002495
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002496 if (surface->configure) {
2497 wl_resource_post_error(&surface->surface.resource,
2498 WL_DISPLAY_ERROR_INVALID_OBJECT,
2499 "surface->configure already set");
2500 return 0;
2501 }
2502
Daniel Stone37816df2012-05-16 18:45:18 +01002503 ws->drag_surface = surface;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002504
Daniel Stone37816df2012-05-16 18:45:18 +01002505 weston_surface_set_position(ws->drag_surface,
2506 wl_fixed_to_double(seat->pointer->x),
2507 wl_fixed_to_double(seat->pointer->y));
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002508
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002509 surface->configure = drag_surface_configure;
2510
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002511 wl_signal_add(&surface->surface.resource.destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01002512 &ws->drag_surface_destroy_listener);
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002513
2514 return 1;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002515}
2516
2517static void
Daniel Stone37816df2012-05-16 18:45:18 +01002518device_release_drag_surface(struct weston_seat *seat)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002519{
Daniel Stone37816df2012-05-16 18:45:18 +01002520 seat->drag_surface->configure = NULL;
2521 undef_region(&seat->drag_surface->input);
2522 wl_list_remove(&seat->drag_surface_destroy_listener.link);
2523 seat->drag_surface = NULL;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002524}
2525
2526static void
Daniel Stone37816df2012-05-16 18:45:18 +01002527device_map_drag_surface(struct weston_seat *seat)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002528{
Daniel Stone37816df2012-05-16 18:45:18 +01002529 if (weston_surface_is_mapped(seat->drag_surface) ||
2530 !seat->drag_surface->buffer)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002531 return;
2532
Daniel Stone37816df2012-05-16 18:45:18 +01002533 wl_list_insert(&seat->sprite->layer_link,
2534 &seat->drag_surface->layer_link);
2535 weston_surface_assign_output(seat->drag_surface);
2536 empty_region(&seat->drag_surface->input);
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002537}
2538
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002539static void
Daniel Stone37816df2012-05-16 18:45:18 +01002540weston_seat_update_drag_surface(struct wl_seat *seat,
2541 int dx, int dy)
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002542{
2543 int surface_changed = 0;
Daniel Stone37816df2012-05-16 18:45:18 +01002544 struct weston_seat *ws = (struct weston_seat *) seat;
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002545
Daniel Stone37816df2012-05-16 18:45:18 +01002546 if (!ws->drag_surface && !seat->drag_surface)
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002547 return;
2548
Daniel Stone37816df2012-05-16 18:45:18 +01002549 if (ws->drag_surface && seat->drag_surface &&
2550 (&ws->drag_surface->surface.resource !=
2551 &seat->drag_surface->resource))
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002552 /* between calls to this funcion we got a new drag_surface */
2553 surface_changed = 1;
2554
Daniel Stone37816df2012-05-16 18:45:18 +01002555 if (!seat->drag_surface || surface_changed) {
2556 device_release_drag_surface(ws);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002557 if (!surface_changed)
2558 return;
2559 }
2560
Daniel Stone37816df2012-05-16 18:45:18 +01002561 if (!ws->drag_surface || surface_changed) {
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002562 struct weston_surface *surface = (struct weston_surface *)
Daniel Stone37816df2012-05-16 18:45:18 +01002563 seat->drag_surface;
2564 if (!device_setup_new_drag_surface(ws, surface))
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002565 return;
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002566 }
2567
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002568 /* the client may not have attached a buffer to the drag surface
2569 * when we setup it up, so check if map is needed on every update */
Daniel Stone37816df2012-05-16 18:45:18 +01002570 device_map_drag_surface(ws);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002571
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +02002572 /* the client may have attached a buffer with a different size to
2573 * the drag surface, causing the input region to be reset */
Daniel Stone37816df2012-05-16 18:45:18 +01002574 if (region_is_undefined(&ws->drag_surface->input))
2575 empty_region(&ws->drag_surface->input);
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +02002576
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002577 if (!dx && !dy)
2578 return;
2579
Daniel Stone37816df2012-05-16 18:45:18 +01002580 weston_surface_set_position(ws->drag_surface,
2581 ws->drag_surface->geometry.x + wl_fixed_to_double(dx),
2582 ws->drag_surface->geometry.y + wl_fixed_to_double(dy));
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002583}
2584
2585WL_EXPORT void
2586weston_compositor_update_drag_surfaces(struct weston_compositor *compositor)
2587{
Daniel Stone4dab5db2012-05-30 16:31:53 +01002588 struct weston_seat *seat;
2589
2590 wl_list_for_each(seat, &compositor->seat_list, link)
2591 weston_seat_update_drag_surface(&seat->seat, 0, 0);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002592}
2593
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002594static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002595bind_output(struct wl_client *client,
2596 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05002597{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002598 struct weston_output *output = data;
2599 struct weston_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04002600 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002601
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04002602 resource = wl_client_add_object(client,
2603 &wl_output_interface, NULL, id, data);
2604
Casey Dahlin9074db52012-04-19 22:50:09 -04002605 wl_list_insert(&output->resource_list, &resource->link);
2606 resource->destroy = unbind_resource;
2607
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05002608 wl_output_send_geometry(resource,
2609 output->x,
2610 output->y,
2611 output->mm_width,
2612 output->mm_height,
2613 output->subpixel,
2614 output->make, output->model);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002615
2616 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05002617 wl_output_send_mode(resource,
2618 mode->flags,
2619 mode->width,
2620 mode->height,
2621 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002622 }
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002623}
2624
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002625static const char vertex_shader[] =
2626 "uniform mat4 proj;\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05002627 "attribute vec2 position;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002628 "attribute vec2 texcoord;\n"
2629 "varying vec2 v_texcoord;\n"
2630 "void main()\n"
2631 "{\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05002632 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002633 " v_texcoord = texcoord;\n"
2634 "}\n";
2635
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002636static const char texture_fragment_shader[] =
Kristian Høgsbergdfce71d2010-12-07 20:19:10 -05002637 "precision mediump float;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002638 "varying vec2 v_texcoord;\n"
2639 "uniform sampler2D tex;\n"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002640 "uniform float alpha;\n"
Scott Moreau69367082012-04-17 19:06:19 -06002641 "uniform float bright;\n"
2642 "uniform float saturation;\n"
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02002643 "uniform float texwidth;\n"
Kristian Høgsberg0b0c2bb2012-05-15 23:16:53 -04002644 "uniform vec4 opaque;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002645 "void main()\n"
2646 "{\n"
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02002647 " if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n"
2648 " v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n"
2649 " discard;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002650 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
Scott Moreau69367082012-04-17 19:06:19 -06002651 " float gray = dot(gl_FragColor.rgb, vec3(0.299, 0.587, 0.114));\n"
2652 " vec3 range = (gl_FragColor.rgb - vec3 (gray, gray, gray)) * saturation;\n"
2653 " gl_FragColor = vec4(vec3(gray + range), gl_FragColor.a);\n"
2654 " gl_FragColor = vec4(vec3(bright, bright, bright) * gl_FragColor.rgb, gl_FragColor.a);\n"
Kristian Høgsberg0b0c2bb2012-05-15 23:16:53 -04002655 " if (opaque.x <= v_texcoord.x && v_texcoord.x < opaque.y &&\n"
2656 " opaque.z <= v_texcoord.y && v_texcoord.y < opaque.w)\n"
2657 " gl_FragColor.a = 1.0;\n"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002658 " gl_FragColor = alpha * gl_FragColor;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002659 "}\n";
2660
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002661static const char solid_fragment_shader[] =
2662 "precision mediump float;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002663 "uniform vec4 color;\n"
Kristian Høgsbergdbae80e2012-03-29 11:34:39 -04002664 "uniform float alpha;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002665 "void main()\n"
2666 "{\n"
Kristian Høgsbergdbae80e2012-03-29 11:34:39 -04002667 " gl_FragColor = alpha * color\n;"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002668 "}\n";
2669
Kristian Høgsberga9468212010-06-14 21:03:11 -04002670static int
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002671compile_shader(GLenum type, const char *source)
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002672{
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002673 GLuint s;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002674 char msg[512];
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002675 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002676
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002677 s = glCreateShader(type);
2678 glShaderSource(s, 1, &source, NULL);
2679 glCompileShader(s);
2680 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002681 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002682 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
2683 fprintf(stderr, "shader info: %s\n", msg);
2684 return GL_NONE;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002685 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002686
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002687 return s;
2688}
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002689
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002690static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002691weston_shader_init(struct weston_shader *shader,
2692 const char *vertex_source, const char *fragment_source)
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002693{
2694 char msg[512];
2695 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002696
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002697 shader->vertex_shader =
2698 compile_shader(GL_VERTEX_SHADER, vertex_source);
2699 shader->fragment_shader =
2700 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
2701
2702 shader->program = glCreateProgram();
2703 glAttachShader(shader->program, shader->vertex_shader);
2704 glAttachShader(shader->program, shader->fragment_shader);
2705 glBindAttribLocation(shader->program, 0, "position");
2706 glBindAttribLocation(shader->program, 1, "texcoord");
2707
2708 glLinkProgram(shader->program);
2709 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002710 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002711 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002712 fprintf(stderr, "link info: %s\n", msg);
2713 return -1;
2714 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002715
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002716 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
2717 shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002718 shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
Scott Moreau69367082012-04-17 19:06:19 -06002719 shader->brightness_uniform = glGetUniformLocation(shader->program, "bright");
2720 shader->saturation_uniform = glGetUniformLocation(shader->program, "saturation");
Pekka Paalanenf55f5442012-02-02 16:49:05 +02002721 shader->color_uniform = glGetUniformLocation(shader->program, "color");
Scott Moreau9fb98242012-05-22 10:18:50 -06002722 shader->texwidth_uniform = glGetUniformLocation(shader->program, "texwidth");
2723 shader->opaque_uniform = glGetUniformLocation(shader->program, "opaque");
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002724
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002725 return 0;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002726}
2727
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002728WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002729weston_output_destroy(struct weston_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002730{
Benjamin Franzkeb6879402012-04-10 18:28:54 +02002731 struct weston_compositor *c = output->compositor;
2732
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04002733 pixman_region32_fini(&output->region);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04002734 pixman_region32_fini(&output->previous_damage);
Casey Dahlin9074db52012-04-19 22:50:09 -04002735 output->compositor->output_id_pool &= ~(1 << output->id);
Benjamin Franzkeb6879402012-04-10 18:28:54 +02002736
2737 wl_display_remove_global(c->wl_display, output->global);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002738}
2739
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002740WL_EXPORT void
Scott Moreau7a1b32a2012-05-27 14:25:02 -06002741weston_text_cursor_position_notify(struct weston_surface *surface,
2742 int32_t cur_pos_x,
2743 int32_t cur_pos_y)
2744{
2745 struct weston_output *output;
2746 int32_t global_x, global_y;
2747
2748 weston_surface_to_global(surface, cur_pos_x, cur_pos_y,
2749 &global_x, &global_y);
2750
2751 wl_list_for_each(output, &surface->compositor->output_list, link)
2752 if (output->zoom.active &&
2753 pixman_region32_contains_point(&output->region,
2754 global_x, global_y, NULL))
2755 weston_output_update_zoom(output,
2756 wl_fixed_from_int(global_x),
2757 wl_fixed_from_int(global_y),
2758 ZOOM_TEXT_CURSOR);
2759}
2760
2761WL_EXPORT void
2762weston_output_update_zoom(struct weston_output *output,
2763 wl_fixed_t fx,
2764 wl_fixed_t fy,
2765 uint32_t type)
Scott Moreauccbf29d2012-02-22 14:21:41 -07002766{
Scott Moreaudc549932012-05-16 08:36:42 -06002767 int32_t x, y;
Scott Moreau7a1b32a2012-05-27 14:25:02 -06002768 float trans_min, trans_max;
Scott Moreauccbf29d2012-02-22 14:21:41 -07002769
Scott Moreau850ca422012-05-21 15:21:25 -06002770 if (output->zoom.level >= 1.0)
Scott Moreauccbf29d2012-02-22 14:21:41 -07002771 return;
2772
Scott Moreaudc549932012-05-16 08:36:42 -06002773 x = wl_fixed_to_int(fx);
2774 y = wl_fixed_to_int(fy);
2775
Scott Moreau7a1b32a2012-05-27 14:25:02 -06002776 output->zoom.trans_x =
2777 (((float)(x - output->x) / output->current->width) *
2778 (output->zoom.level * 2)) - output->zoom.level;
2779 output->zoom.trans_y =
2780 (((float)(y - output->y) / output->current->height) *
2781 (output->zoom.level * 2)) - output->zoom.level;
2782
2783 if (type == ZOOM_TEXT_CURSOR) {
2784 output->zoom.trans_x *= 1 / output->zoom.level;
2785 output->zoom.trans_y *= 1 / output->zoom.level;
2786
2787 trans_max = output->zoom.level * 2 - output->zoom.level;
2788 trans_min = -trans_max;
2789
2790 if (output->zoom.trans_x > trans_max)
2791 output->zoom.trans_x = trans_max;
2792 else if (output->zoom.trans_x < trans_min)
2793 output->zoom.trans_x = trans_min;
2794 if (output->zoom.trans_y > trans_max)
2795 output->zoom.trans_y = trans_max;
2796 else if (output->zoom.trans_y < trans_min)
2797 output->zoom.trans_y = trans_min;
2798 }
Scott Moreauccbf29d2012-02-22 14:21:41 -07002799
2800 output->dirty = 1;
2801 weston_output_damage(output);
2802}
2803
2804WL_EXPORT void
2805weston_output_update_matrix(struct weston_output *output)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002806{
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01002807 int flip;
Scott Moreau850ca422012-05-21 15:21:25 -06002808 float magnification;
Scott Moreauccbf29d2012-02-22 14:21:41 -07002809 struct weston_matrix camera;
2810 struct weston_matrix modelview;
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05002811
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002812 weston_matrix_init(&output->matrix);
2813 weston_matrix_translate(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002814 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
2815 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01002816
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002817 flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002818 weston_matrix_scale(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002819 2.0 / (output->current->width + output->border.left + output->border.right),
2820 flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
Scott Moreau850ca422012-05-21 15:21:25 -06002821
Scott Moreauccbf29d2012-02-22 14:21:41 -07002822 if (output->zoom.active) {
Scott Moreau850ca422012-05-21 15:21:25 -06002823 magnification = 1 / (1 - output->zoom.level);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002824 weston_matrix_init(&camera);
2825 weston_matrix_init(&modelview);
2826 weston_matrix_translate(&camera, output->zoom.trans_x, flip * output->zoom.trans_y, 0);
2827 weston_matrix_invert(&modelview, &camera);
Scott Moreau850ca422012-05-21 15:21:25 -06002828 weston_matrix_scale(&modelview, magnification, magnification, 1.0);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002829 weston_matrix_multiply(&output->matrix, &modelview);
2830 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002831
Scott Moreauccbf29d2012-02-22 14:21:41 -07002832 output->dirty = 0;
2833}
2834
2835WL_EXPORT void
2836weston_output_move(struct weston_output *output, int x, int y)
2837{
2838 output->x = x;
2839 output->y = y;
2840
2841 pixman_region32_init(&output->previous_damage);
2842 pixman_region32_init_rect(&output->region, x, y,
2843 output->current->width,
2844 output->current->height);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002845}
2846
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002847WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002848weston_output_init(struct weston_output *output, struct weston_compositor *c,
2849 int x, int y, int width, int height, uint32_t flags)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002850{
2851 output->compositor = c;
2852 output->x = x;
2853 output->y = y;
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002854 output->border.top = 0;
2855 output->border.bottom = 0;
2856 output->border.left = 0;
2857 output->border.right = 0;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002858 output->mm_width = width;
2859 output->mm_height = height;
Scott Moreauccbf29d2012-02-22 14:21:41 -07002860 output->dirty = 1;
Scott Moreau062be7e2012-04-20 13:37:33 -06002861 wl_list_init(&output->read_pixels_list);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002862
2863 output->zoom.active = 0;
2864 output->zoom.increment = 0.05;
Scott Moreau850ca422012-05-21 15:21:25 -06002865 output->zoom.level = 0.0;
Scott Moreauccbf29d2012-02-22 14:21:41 -07002866 output->zoom.trans_x = 0.0;
2867 output->zoom.trans_y = 0.0;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002868
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002869 output->flags = flags;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002870 weston_output_move(output, x, y);
Benjamin Franzke78db8482012-04-10 18:35:33 +02002871 weston_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002872
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -04002873 wl_signal_init(&output->frame_signal);
Kristian Høgsberg33418202011-08-16 23:01:28 -04002874 wl_list_init(&output->frame_callback_list);
Casey Dahlin9074db52012-04-19 22:50:09 -04002875 wl_list_init(&output->resource_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02002876
Casey Dahlin58ba1372012-04-19 22:50:08 -04002877 output->id = ffs(~output->compositor->output_id_pool) - 1;
2878 output->compositor->output_id_pool |= 1 << output->id;
2879
Benjamin Franzkeb6879402012-04-10 18:28:54 +02002880 output->global =
2881 wl_display_add_global(c->wl_display, &wl_output_interface,
2882 output, bind_output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002883}
2884
Scott Moreau062be7e2012-04-20 13:37:33 -06002885WL_EXPORT void
2886weston_output_do_read_pixels(struct weston_output *output)
2887{
2888 struct weston_read_pixels *r, *next;
2889
2890 glPixelStorei(GL_PACK_ALIGNMENT, 1);
2891 wl_list_for_each_safe(r, next, &output->read_pixels_list, link) {
2892 glReadPixels(r->x, r->y, r->width, r->height,
2893 output->compositor->read_format,
2894 GL_UNSIGNED_BYTE, r->data);
2895 r->done(r, output);
2896 }
2897}
2898
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002899static void
Kristian Høgsberga8873122011-11-23 10:39:34 -05002900compositor_bind(struct wl_client *client,
2901 void *data, uint32_t version, uint32_t id)
2902{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002903 struct weston_compositor *compositor = data;
Kristian Høgsberga8873122011-11-23 10:39:34 -05002904
2905 wl_client_add_object(client, &wl_compositor_interface,
2906 &compositor_interface, id, compositor);
2907}
2908
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002909WL_EXPORT int
Daniel Stonebaf43592012-06-01 11:11:10 -04002910weston_compositor_init(struct weston_compositor *ec,
2911 struct wl_display *display,
2912 int argc,
Daniel Stonec1be8e52012-06-01 11:14:02 -04002913 char *argv[],
2914 const char *config_file)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002915{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002916 struct wl_event_loop *loop;
Kristian Høgsbergd711d0c2011-01-14 17:28:21 -05002917 const char *extensions;
Daniel Stonee2ef43a2012-06-01 12:14:05 +01002918 struct xkb_rule_names xkb_names;
2919 const struct config_key keyboard_config_keys[] = {
2920 { "keymap_rules", CONFIG_KEY_STRING, &xkb_names.rules },
2921 { "keymap_model", CONFIG_KEY_STRING, &xkb_names.model },
2922 { "keymap_layout", CONFIG_KEY_STRING, &xkb_names.layout },
2923 { "keymap_variant", CONFIG_KEY_STRING, &xkb_names.variant },
2924 { "keymap_options", CONFIG_KEY_STRING, &xkb_names.options },
2925 };
2926 const struct config_section cs[] = {
2927 { "keyboard",
2928 keyboard_config_keys, ARRAY_LENGTH(keyboard_config_keys) },
2929 };
2930
2931 memset(&xkb_names, 0, sizeof(xkb_names));
2932 parse_config_file(config_file, cs, ARRAY_LENGTH(cs), ec);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002933
Kristian Høgsbergf9212892008-10-11 18:40:23 -04002934 ec->wl_display = display;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04002935 wl_signal_init(&ec->destroy_signal);
2936 wl_signal_init(&ec->activate_signal);
2937 wl_signal_init(&ec->lock_signal);
2938 wl_signal_init(&ec->unlock_signal);
Benjamin Franzkebfeda132012-01-30 14:04:04 +01002939 ec->launcher_sock = weston_environment_get_fd("WESTON_LAUNCHER_SOCK");
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002940
Casey Dahlin58ba1372012-04-19 22:50:08 -04002941 ec->output_id_pool = 0;
2942
Kristian Høgsberga8873122011-11-23 10:39:34 -05002943 if (!wl_display_add_global(display, &wl_compositor_interface,
2944 ec, compositor_bind))
2945 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05002946
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04002947 wl_display_init_shm(display);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002948
2949 ec->image_target_texture_2d =
2950 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
2951 ec->image_target_renderbuffer_storage = (void *)
2952 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
2953 ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
2954 ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
2955 ec->bind_display =
2956 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
2957 ec->unbind_display =
2958 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
2959
2960 extensions = (const char *) glGetString(GL_EXTENSIONS);
Pekka Paalanen299e58d2012-04-12 14:45:35 +03002961 if (!extensions) {
2962 fprintf(stderr, "Retrieving GL extension string failed.\n");
2963 return -1;
2964 }
2965
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002966 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
2967 fprintf(stderr,
2968 "GL_EXT_texture_format_BGRA8888 not available\n");
2969 return -1;
2970 }
2971
Pekka Paalanena1d57db2012-04-17 15:02:08 +03002972 if (strstr(extensions, "GL_EXT_read_format_bgra"))
2973 ec->read_format = GL_BGRA_EXT;
2974 else
2975 ec->read_format = GL_RGBA;
Kristian Høgsbergf9247dd2012-03-27 15:25:46 -04002976
Pekka Paalanen52bfbaa2012-04-11 16:19:37 +03002977 if (strstr(extensions, "GL_EXT_unpack_subimage"))
2978 ec->has_unpack_subimage = 1;
Kristian Høgsbergfb6de222012-03-27 17:10:13 -04002979
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002980 extensions =
2981 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
Pekka Paalanen299e58d2012-04-12 14:45:35 +03002982 if (!extensions) {
2983 fprintf(stderr, "Retrieving EGL extension string failed.\n");
2984 return -1;
2985 }
2986
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002987 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
2988 ec->has_bind_display = 1;
2989 if (ec->has_bind_display)
2990 ec->bind_display(ec->display, ec->wl_display);
Kristian Høgsberg3d5bae02010-10-06 21:17:40 -04002991
Kristian Høgsberg201a9042008-12-10 00:40:50 -05002992 wl_list_init(&ec->surface_list);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05002993 wl_list_init(&ec->layer_list);
Daniel Stone37816df2012-05-16 18:45:18 +01002994 wl_list_init(&ec->seat_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002995 wl_list_init(&ec->output_list);
Daniel Stone325fc2d2012-05-30 16:31:58 +01002996 wl_list_init(&ec->key_binding_list);
2997 wl_list_init(&ec->button_binding_list);
2998 wl_list_init(&ec->axis_binding_list);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002999 wl_list_init(&ec->animation_list);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003000 weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04003001 ec->fade.animation.frame = fade_frame;
3002 wl_list_init(&ec->fade.animation.link);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04003003
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05003004 weston_layer_init(&ec->fade_layer, &ec->layer_list);
3005 weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
3006
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003007 screenshooter_create(ec);
Scott Moreau7a1b32a2012-05-27 14:25:02 -06003008 text_cursor_position_notifier_create(ec);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003009
Scott Moreauff1db4a2012-04-17 19:06:18 -06003010 ec->ping_handler = NULL;
3011
Kristian Høgsbergdade6492012-01-04 21:47:30 -05003012 wl_data_device_manager_init(ec->wl_display);
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04003013
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003014 glActiveTexture(GL_TEXTURE0);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04003015
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003016 if (weston_shader_init(&ec->texture_shader,
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04003017 vertex_shader, texture_fragment_shader) < 0)
Kristian Høgsberga9468212010-06-14 21:03:11 -04003018 return -1;
Pekka Paalanenf55f5442012-02-02 16:49:05 +02003019 if (weston_shader_init(&ec->solid_shader,
3020 vertex_shader, solid_fragment_shader) < 0)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04003021 return -1;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05003022
Daniel Stonee2ef43a2012-06-01 12:14:05 +01003023 weston_compositor_xkb_init(ec, &xkb_names);
3024
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05003025 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04003026 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
Pekka Paalanen7296e792011-12-07 16:22:00 +02003027 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04003028
Kristian Høgsberg7ea10862012-03-05 17:49:30 -05003029 ec->input_loop = wl_event_loop_create();
3030
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003031 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04003032
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003033 return 0;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003034}
3035
Benjamin Franzkeb8263022011-08-30 11:32:47 +02003036WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003037weston_compositor_shutdown(struct weston_compositor *ec)
Matt Roper361d2ad2011-08-29 13:52:23 -07003038{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003039 struct weston_output *output, *next;
Matt Roper361d2ad2011-08-29 13:52:23 -07003040
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003041 wl_event_source_remove(ec->idle_source);
Jonas Ådahlc97af922012-03-28 22:36:09 +02003042 if (ec->input_loop_source)
3043 wl_event_source_remove(ec->input_loop_source);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003044
Matt Roper361d2ad2011-08-29 13:52:23 -07003045 /* Destroy all outputs associated with this compositor */
Tiago Vignattib303a1d2011-12-18 22:27:40 +02003046 wl_list_for_each_safe(output, next, &ec->output_list, link)
Matt Roper361d2ad2011-08-29 13:52:23 -07003047 output->destroy(output);
Pekka Paalanen4738f3b2012-01-02 15:47:07 +02003048
Daniel Stone325fc2d2012-05-30 16:31:58 +01003049 weston_binding_list_destroy_all(&ec->key_binding_list);
3050 weston_binding_list_destroy_all(&ec->button_binding_list);
3051 weston_binding_list_destroy_all(&ec->axis_binding_list);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003052
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003053 wl_array_release(&ec->vertices);
3054 wl_array_release(&ec->indices);
Jonas Ådahlc97af922012-03-28 22:36:09 +02003055
3056 wl_event_loop_destroy(ec->input_loop);
Matt Roper361d2ad2011-08-29 13:52:23 -07003057}
3058
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003059static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003060{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003061 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003062
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04003063 fprintf(stderr, "caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003064 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003065
3066 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003067}
3068
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003069static void
3070on_segv_signal(int s, siginfo_t *siginfo, void *context)
3071{
3072 void *buffer[32];
3073 int i, count;
3074 Dl_info info;
3075
3076 fprintf(stderr, "caught segv\n");
3077
3078 count = backtrace(buffer, ARRAY_LENGTH(buffer));
3079 for (i = 0; i < count; i++) {
3080 dladdr(buffer[i], &info);
3081 fprintf(stderr, " [%016lx] %s (%s)\n",
3082 (long) buffer[i],
3083 info.dli_sname ? info.dli_sname : "--",
3084 info.dli_fname);
3085 }
3086
3087 longjmp(segv_jmp_buf, 1);
3088}
3089
3090
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003091static void *
3092load_module(const char *name, const char *entrypoint, void **handle)
3093{
3094 char path[PATH_MAX];
3095 void *module, *init;
3096
3097 if (name[0] != '/')
Chad Versacebf381902012-05-23 23:42:15 -07003098 snprintf(path, sizeof path, "%s/%s", MODULEDIR, name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003099 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02003100 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003101
3102 module = dlopen(path, RTLD_LAZY);
3103 if (!module) {
3104 fprintf(stderr,
Pekka Paalanenf31ad102012-04-26 10:31:36 +03003105 "failed to load module '%s': %s\n", path, dlerror());
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003106 return NULL;
3107 }
3108
3109 init = dlsym(module, entrypoint);
3110 if (!init) {
3111 fprintf(stderr,
Pekka Paalanenf31ad102012-04-26 10:31:36 +03003112 "failed to lookup init function in '%s': %s\n",
3113 path, dlerror());
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003114 return NULL;
3115 }
3116
3117 return init;
3118}
3119
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003120int main(int argc, char *argv[])
3121{
3122 struct wl_display *display;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003123 struct weston_compositor *ec;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003124 struct wl_event_source *signals[4];
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003125 struct wl_event_loop *loop;
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003126 struct sigaction segv_action;
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003127 void *shell_module, *backend_module, *xserver_module;
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003128 int (*module_init)(struct weston_compositor *ec);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003129 struct weston_compositor
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003130 *(*backend_init)(struct wl_display *display,
Daniel Stonec1be8e52012-06-01 11:14:02 -04003131 int argc, char *argv[], const char *config_file);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003132 int i;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003133 char *backend = NULL;
3134 char *shell = NULL;
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003135 char *module = NULL;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003136 int32_t idle_time = 300;
Scott Moreaue17f6102012-04-25 10:03:06 -06003137 int32_t xserver = 0;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003138 char *socket_name = NULL;
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003139 char *config_file;
3140
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04003141 const struct config_key shell_config_keys[] = {
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003142 { "type", CONFIG_KEY_STRING, &shell },
3143 };
3144
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04003145 const struct config_section cs[] = {
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003146 { "shell",
3147 shell_config_keys, ARRAY_LENGTH(shell_config_keys) },
3148 };
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04003149
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003150 const struct weston_option core_options[] = {
3151 { WESTON_OPTION_STRING, "backend", 'B', &backend },
3152 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
3153 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003154 { WESTON_OPTION_BOOLEAN, "xserver", 0, &xserver },
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003155 { WESTON_OPTION_STRING, "module", 0, &module },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04003156 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05003157
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003158 argc = parse_options(core_options,
3159 ARRAY_LENGTH(core_options), argc, argv);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003160
3161 display = wl_display_create();
3162
Tiago Vignatti2116b892011-08-08 05:52:59 -07003163 loop = wl_display_get_event_loop(display);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003164 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
3165 display);
3166 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
3167 display);
3168 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
3169 display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07003170
3171 wl_list_init(&child_process_list);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003172 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
3173 NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05003174
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003175 segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
3176 segv_action.sa_sigaction = on_segv_signal;
Pekka Paalanen8423a892012-01-19 16:48:37 +02003177 sigemptyset(&segv_action.sa_mask);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003178 sigaction(SIGSEGV, &segv_action, NULL);
3179
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003180 if (!backend) {
3181 if (getenv("WAYLAND_DISPLAY"))
3182 backend = "wayland-backend.so";
3183 else if (getenv("DISPLAY"))
3184 backend = "x11-backend.so";
3185 else if (getenv("OPENWFD"))
3186 backend = "openwfd-backend.so";
3187 else
3188 backend = "drm-backend.so";
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04003189 }
3190
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003191 config_file = config_file_path("weston.ini");
3192 parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell);
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003193
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003194 backend_init = load_module(backend, "backend_init", &backend_module);
3195 if (!backend_init)
3196 exit(EXIT_FAILURE);
Kristian Høgsberga9410222011-01-14 17:22:35 -05003197
Daniel Stonec1be8e52012-06-01 11:14:02 -04003198 ec = backend_init(display, argc, argv, config_file);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05003199 if (ec == NULL) {
3200 fprintf(stderr, "failed to create compositor\n");
3201 exit(EXIT_FAILURE);
3202 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04003203
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003204 for (i = 1; argv[i]; i++)
3205 fprintf(stderr, "unhandled option: %s\n", argv[i]);
3206 if (argv[1])
3207 exit(EXIT_FAILURE);
3208
Daniel Stonec1be8e52012-06-01 11:14:02 -04003209 free(config_file);
Daniel Stone855028f2012-05-01 20:37:10 +01003210
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003211 ec->option_idle_time = idle_time;
3212 ec->idle_time = idle_time;
Pekka Paalanen7296e792011-12-07 16:22:00 +02003213
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003214 module_init = NULL;
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003215 if (xserver)
Tiago Vignatti629ce232012-05-23 23:04:14 +03003216 module_init = load_module("xwayland.so",
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003217 "weston_xserver_init",
3218 &xserver_module);
3219 if (module_init && module_init(ec) < 0)
3220 exit(EXIT_FAILURE);
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003221
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003222 if (!shell)
3223 shell = "desktop-shell.so";
3224 module_init = load_module(shell, "shell_init", &shell_module);
3225 if (!module_init || module_init(ec) < 0)
3226 exit(EXIT_FAILURE);
3227
3228
3229 module_init = NULL;
3230 if (module)
3231 module_init = load_module(module, "module_init", NULL);
3232 if (module_init && module_init(ec) < 0)
Tiago Vignattie4faa2a2012-04-16 17:31:44 +03003233 exit(EXIT_FAILURE);
3234
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003235 if (wl_display_add_socket(display, socket_name)) {
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003236 fprintf(stderr, "failed to add socket: %m\n");
3237 exit(EXIT_FAILURE);
3238 }
3239
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02003240 weston_compositor_dpms_on(ec);
Pekka Paalanenc0444e32012-01-05 16:28:21 +02003241 weston_compositor_wake(ec);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003242 if (setjmp(segv_jmp_buf) == 0)
3243 wl_display_run(display);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003244
Pekka Paalanen0135abe2012-01-03 10:01:20 +02003245 /* prevent further rendering while shutting down */
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05003246 ec->state = WESTON_COMPOSITOR_SLEEPING;
Pekka Paalanen0135abe2012-01-03 10:01:20 +02003247
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003248 wl_signal_emit(&ec->destroy_signal, ec);
Pekka Paalanen3c647232011-12-22 13:43:43 +02003249
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003250 if (ec->has_bind_display)
3251 ec->unbind_display(ec->display, display);
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05003252
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003253 for (i = ARRAY_LENGTH(signals); i;)
3254 wl_event_source_remove(signals[--i]);
3255
Daniel Stone855028f2012-05-01 20:37:10 +01003256 weston_compositor_xkb_destroy(ec);
3257
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05003258 ec->destroy(ec);
Tiago Vignatti9e2be082011-12-19 00:04:46 +02003259 wl_display_destroy(display);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05003260
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003261 return 0;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003262}