blob: f273e86b83b2526cde396f37e8dd04413c74574b [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>
Martin Minarikf12c2872012-06-11 00:57:39 +020041#include <sys/utsname.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040042#include <unistd.h>
Kristian Høgsberg54879822008-11-23 17:07:32 -050043#include <math.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040044#include <linux/input.h>
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -040045#include <dlfcn.h>
Kristian Høgsberg85449032011-05-02 12:11:07 -040046#include <signal.h>
Kristian Høgsberg0690da62012-01-16 11:53:54 -050047#include <setjmp.h>
Kristian Høgsberga411c8b2012-06-08 16:16:52 -040048#include <sys/time.h>
49#include <time.h>
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -040050#include <ctype.h>
Kristian Høgsberg890bc052008-12-30 14:31:33 -050051
Pekka Paalanen50719bc2011-11-22 14:18:50 +020052#include <wayland-server.h>
Kristian Høgsberg82863022010-06-04 21:52:02 -040053#include "compositor.h"
Pekka Paalanen51aaf642012-05-30 15:53:41 +030054#include "../shared/os-compatibility.h"
Martin Minarik19e6f262012-06-07 13:08:46 +020055#include "log.h"
Kristian Høgsberga411c8b2012-06-08 16:16:52 -040056#include "git-version.h"
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050057
Kristian Høgsberg27da5382011-06-21 17:32:25 -040058static struct wl_list child_process_list;
Kristian Høgsberg0690da62012-01-16 11:53:54 -050059static jmp_buf segv_jmp_buf;
Kristian Høgsberg27da5382011-06-21 17:32:25 -040060
61static int
62sigchld_handler(int signal_number, void *data)
63{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050064 struct weston_process *p;
Kristian Høgsberg27da5382011-06-21 17:32:25 -040065 int status;
66 pid_t pid;
67
Bill Spitzak027b9622012-03-17 15:22:03 -070068 pid = waitpid(-1, &status, WNOHANG);
69 if (!pid)
70 return 1;
71
Kristian Høgsberg27da5382011-06-21 17:32:25 -040072 wl_list_for_each(p, &child_process_list, link) {
73 if (p->pid == pid)
74 break;
75 }
76
77 if (&p->link == &child_process_list) {
Martin Minarik6d118362012-06-07 18:01:59 +020078 weston_log("unknown child process exited\n");
Kristian Høgsberg27da5382011-06-21 17:32:25 -040079 return 1;
80 }
81
82 wl_list_remove(&p->link);
83 p->cleanup(p, status);
84
85 return 1;
86}
87
Alex Wu2dda6042012-04-17 17:20:47 +080088WL_EXPORT int
89weston_output_switch_mode(struct weston_output *output, struct weston_mode *mode)
90{
91 if (!output->switch_mode)
92 return -1;
93
94 return output->switch_mode(output, mode);
95}
96
Kristian Høgsberg27da5382011-06-21 17:32:25 -040097WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050098weston_watch_process(struct weston_process *process)
Kristian Høgsberg27da5382011-06-21 17:32:25 -040099{
100 wl_list_insert(&child_process_list, &process->link);
101}
102
Benjamin Franzke06286262011-05-06 19:12:33 +0200103static void
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200104child_client_exec(int sockfd, const char *path)
105{
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500106 int clientfd;
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200107 char s[32];
Pekka Paalanenc47ddfd2011-12-08 10:44:56 +0200108 sigset_t allsigs;
109
110 /* do not give our signal mask to the new process */
111 sigfillset(&allsigs);
112 sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200113
Kristian Høgsbergeb764842012-01-31 22:17:25 -0500114 /* Launch clients as the user. */
115 seteuid(getuid());
116
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500117 /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
118 * non-CLOEXEC fd to pass through exec. */
119 clientfd = dup(sockfd);
120 if (clientfd == -1) {
Martin Minarik6d118362012-06-07 18:01:59 +0200121 weston_log("compositor: dup failed: %m\n");
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500122 return;
123 }
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200124
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500125 snprintf(s, sizeof s, "%d", clientfd);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200126 setenv("WAYLAND_SOCKET", s, 1);
127
128 if (execl(path, path, NULL) < 0)
Martin Minarik6d118362012-06-07 18:01:59 +0200129 weston_log("compositor: executing '%s' failed: %m\n",
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200130 path);
131}
132
133WL_EXPORT struct wl_client *
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500134weston_client_launch(struct weston_compositor *compositor,
135 struct weston_process *proc,
136 const char *path,
137 weston_process_cleanup_func_t cleanup)
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200138{
139 int sv[2];
140 pid_t pid;
141 struct wl_client *client;
142
Pekka Paalanen51aaf642012-05-30 15:53:41 +0300143 if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +0200144 weston_log("weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200145 "socketpair failed while launching '%s': %m\n",
146 path);
147 return NULL;
148 }
149
150 pid = fork();
151 if (pid == -1) {
152 close(sv[0]);
153 close(sv[1]);
Martin Minarik6d118362012-06-07 18:01:59 +0200154 weston_log("weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200155 "fork failed while launching '%s': %m\n", path);
156 return NULL;
157 }
158
159 if (pid == 0) {
160 child_client_exec(sv[1], path);
161 exit(-1);
162 }
163
164 close(sv[1]);
165
166 client = wl_client_create(compositor->wl_display, sv[0]);
167 if (!client) {
168 close(sv[0]);
Martin Minarik6d118362012-06-07 18:01:59 +0200169 weston_log("weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200170 "wl_client_create failed while launching '%s'.\n",
171 path);
172 return NULL;
173 }
174
175 proc->pid = pid;
176 proc->cleanup = cleanup;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500177 weston_watch_process(proc);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200178
179 return client;
180}
181
182static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400183surface_handle_buffer_destroy(struct wl_listener *listener, void *data)
Benjamin Franzke06286262011-05-06 19:12:33 +0200184{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500185 struct weston_surface *es =
186 container_of(listener, struct weston_surface,
187 buffer_destroy_listener);
Benjamin Franzke06286262011-05-06 19:12:33 +0200188
Kristian Høgsberg24596942011-10-24 17:51:02 -0400189 es->buffer = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200190}
191
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500192static const pixman_region32_data_t undef_region_data;
193
194static void
195undef_region(pixman_region32_t *region)
196{
Kristian Høgsberg66a099b2012-05-29 16:49:45 -0400197 if (region->data != &undef_region_data)
198 pixman_region32_fini(region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500199 region->data = (pixman_region32_data_t *) &undef_region_data;
200}
201
202static int
203region_is_undefined(pixman_region32_t *region)
204{
205 return region->data == &undef_region_data;
206}
207
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +0200208static void
209empty_region(pixman_region32_t *region)
210{
211 if (!region_is_undefined(region))
212 pixman_region32_fini(region);
213
214 pixman_region32_init(region);
215}
216
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500217WL_EXPORT struct weston_surface *
Kristian Høgsberg18c93002012-01-27 11:58:31 -0500218weston_surface_create(struct weston_compositor *compositor)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500219{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500220 struct weston_surface *surface;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400221
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200222 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400223 if (surface == NULL)
224 return NULL;
225
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400226 wl_signal_init(&surface->surface.resource.destroy_signal);
Kristian Høgsberg48891542012-02-23 17:38:33 -0500227
Kristian Høgsbergf6b14712011-01-06 15:32:14 -0500228 wl_list_init(&surface->link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500229 wl_list_init(&surface->layer_link);
Kristian Høgsbergc551bd22010-12-06 16:43:16 -0500230
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400231 surface->surface.resource.client = NULL;
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400232
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500233 surface->compositor = compositor;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200234 surface->image = EGL_NO_IMAGE_KHR;
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400235 surface->alpha = 1.0;
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400236 surface->blend = 1;
Kristian Høgsberg0b0c2bb2012-05-15 23:16:53 -0400237 surface->opaque_rect[0] = 0.0;
238 surface->opaque_rect[1] = 0.0;
239 surface->opaque_rect[2] = 0.0;
240 surface->opaque_rect[3] = 0.0;
Juan Zhao46436612012-03-20 01:48:46 +0800241 surface->pitch = 1;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400242
Benjamin Franzke06286262011-05-06 19:12:33 +0200243 surface->buffer = NULL;
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400244 surface->output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200245
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400246 pixman_region32_init(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500247 pixman_region32_init(&surface->opaque);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500248 pixman_region32_init(&surface->clip);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500249 undef_region(&surface->input);
Pekka Paalanen730d87e2012-02-09 16:39:38 +0200250 pixman_region32_init(&surface->transform.opaque);
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500251 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400252
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -0400253 surface->buffer_destroy_listener.notify =
254 surface_handle_buffer_destroy;
Benjamin Franzke06286262011-05-06 19:12:33 +0200255
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200256 wl_list_init(&surface->geometry.transformation_list);
Pekka Paalanencd403622012-01-25 13:37:39 +0200257 wl_list_insert(&surface->geometry.transformation_list,
258 &surface->transform.position.link);
259 weston_matrix_init(&surface->transform.position.matrix);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200260 pixman_region32_init(&surface->transform.boundingbox);
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200261 surface->geometry.dirty = 1;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500262
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400263 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500264}
265
Alex Wu8811bf92012-02-28 18:07:54 +0800266WL_EXPORT void
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500267weston_surface_set_color(struct weston_surface *surface,
268 GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
269{
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500270 surface->color[0] = red;
271 surface->color[1] = green;
272 surface->color[2] = blue;
273 surface->color[3] = alpha;
274 surface->shader = &surface->compositor->solid_shader;
275}
276
Kristian Høgsberge4c1a5f2012-06-18 13:17:32 -0400277WL_EXPORT void
278weston_surface_to_global_float(struct weston_surface *surface,
279 GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y)
Pekka Paalanenece8a012012-02-08 15:23:15 +0200280{
281 if (surface->transform.enabled) {
282 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
283
284 weston_matrix_transform(&surface->transform.matrix, &v);
285
286 if (fabsf(v.f[3]) < 1e-6) {
Martin Minarik6d118362012-06-07 18:01:59 +0200287 weston_log("warning: numerical instability in "
Pekka Paalanenece8a012012-02-08 15:23:15 +0200288 "weston_surface_to_global(), divisor = %g\n",
289 v.f[3]);
290 *x = 0;
291 *y = 0;
292 return;
293 }
294
295 *x = v.f[0] / v.f[3];
296 *y = v.f[1] / v.f[3];
297 } else {
298 *x = sx + surface->geometry.x;
299 *y = sy + surface->geometry.y;
300 }
301}
302
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500303WL_EXPORT void
Kristian Høgsberg323ee042012-02-17 12:45:43 -0500304weston_surface_damage_below(struct weston_surface *surface)
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200305{
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500306 struct weston_compositor *compositor = surface->compositor;
307 pixman_region32_t damage;
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200308
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500309 pixman_region32_init(&damage);
310 pixman_region32_subtract(&damage, &surface->transform.boundingbox,
311 &surface->clip);
312 pixman_region32_union(&compositor->damage,
313 &compositor->damage, &damage);
314 pixman_region32_fini(&damage);
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200315}
316
317static void
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200318surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy,
319 int32_t width, int32_t height,
320 pixman_region32_t *bbox)
321{
Pekka Paalanen219b9822012-02-08 15:38:37 +0200322 GLfloat min_x = HUGE_VALF, min_y = HUGE_VALF;
323 GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200324 int32_t s[4][2] = {
325 { sx, sy },
326 { sx, sy + height },
327 { sx + width, sy },
328 { sx + width, sy + height }
329 };
Pekka Paalanen219b9822012-02-08 15:38:37 +0200330 GLfloat int_x, int_y;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200331 int i;
332
333 for (i = 0; i < 4; ++i) {
Pekka Paalanen219b9822012-02-08 15:38:37 +0200334 GLfloat x, y;
Kristian Høgsberge4c1a5f2012-06-18 13:17:32 -0400335 weston_surface_to_global_float(surface,
336 s[i][0], s[i][1], &x, &y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200337 if (x < min_x)
338 min_x = x;
339 if (x > max_x)
340 max_x = x;
341 if (y < min_y)
342 min_y = y;
343 if (y > max_y)
344 max_y = y;
345 }
346
Pekka Paalanen219b9822012-02-08 15:38:37 +0200347 int_x = floorf(min_x);
348 int_y = floorf(min_y);
349 pixman_region32_init_rect(bbox, int_x, int_y,
350 ceilf(max_x) - int_x, ceilf(max_y) - int_y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200351}
352
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200353static void
354weston_surface_update_transform_disable(struct weston_surface *surface)
355{
356 surface->transform.enabled = 0;
357
Pekka Paalanencc2f8682012-02-13 10:34:04 +0200358 /* round off fractions when not transformed */
359 surface->geometry.x = roundf(surface->geometry.x);
360 surface->geometry.y = roundf(surface->geometry.y);
361
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200362 pixman_region32_init_rect(&surface->transform.boundingbox,
363 surface->geometry.x,
364 surface->geometry.y,
365 surface->geometry.width,
366 surface->geometry.height);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500367
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400368 if (surface->alpha == 1.0) {
Kristian Høgsberg3b4af202012-02-28 09:19:39 -0500369 pixman_region32_copy(&surface->transform.opaque,
370 &surface->opaque);
371 pixman_region32_translate(&surface->transform.opaque,
372 surface->geometry.x,
373 surface->geometry.y);
374 }
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200375}
376
377static int
378weston_surface_update_transform_enable(struct weston_surface *surface)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200379{
380 struct weston_matrix *matrix = &surface->transform.matrix;
381 struct weston_matrix *inverse = &surface->transform.inverse;
382 struct weston_transform *tform;
383
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200384 surface->transform.enabled = 1;
385
386 /* Otherwise identity matrix, but with x and y translation. */
387 surface->transform.position.matrix.d[12] = surface->geometry.x;
388 surface->transform.position.matrix.d[13] = surface->geometry.y;
389
390 weston_matrix_init(matrix);
391 wl_list_for_each(tform, &surface->geometry.transformation_list, link)
392 weston_matrix_multiply(matrix, &tform->matrix);
393
394 if (weston_matrix_invert(inverse, matrix) < 0) {
395 /* Oops, bad total transformation, not invertible */
Martin Minarik6d118362012-06-07 18:01:59 +0200396 weston_log("error: weston_surface %p"
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200397 " transformation not invertible.\n", surface);
398 return -1;
399 }
400
401 surface_compute_bbox(surface, 0, 0, surface->geometry.width,
402 surface->geometry.height,
403 &surface->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500404
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200405 return 0;
406}
407
408WL_EXPORT void
409weston_surface_update_transform(struct weston_surface *surface)
410{
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200411 if (!surface->geometry.dirty)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200412 return;
413
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200414 surface->geometry.dirty = 0;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200415
Kristian Høgsberg323ee042012-02-17 12:45:43 -0500416 weston_surface_damage_below(surface);
Pekka Paalanen96516782012-02-09 15:32:15 +0200417
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200418 pixman_region32_fini(&surface->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500419 pixman_region32_fini(&surface->transform.opaque);
420 pixman_region32_init(&surface->transform.opaque);
421
422 if (region_is_undefined(&surface->input))
423 pixman_region32_init_rect(&surface->input, 0, 0,
424 surface->geometry.width,
425 surface->geometry.height);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200426
Pekka Paalanencd403622012-01-25 13:37:39 +0200427 /* transform.position is always in transformation_list */
428 if (surface->geometry.transformation_list.next ==
429 &surface->transform.position.link &&
430 surface->geometry.transformation_list.prev ==
431 &surface->transform.position.link) {
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200432 weston_surface_update_transform_disable(surface);
433 } else {
434 if (weston_surface_update_transform_enable(surface) < 0)
435 weston_surface_update_transform_disable(surface);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200436 }
Pekka Paalanen96516782012-02-09 15:32:15 +0200437
438 /* weston_surface_damage() without update */
439 pixman_region32_union(&surface->damage, &surface->damage,
440 &surface->transform.boundingbox);
441
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300442 if (weston_surface_is_mapped(surface))
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +0200443 weston_surface_assign_output(surface);
444
Pekka Paalanen96516782012-02-09 15:32:15 +0200445 weston_compositor_schedule_repaint(surface->compositor);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200446}
447
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200448WL_EXPORT void
Daniel Stonebd3489b2012-05-08 17:17:53 +0100449weston_surface_to_global_fixed(struct weston_surface *surface,
450 wl_fixed_t sx, wl_fixed_t sy,
451 wl_fixed_t *x, wl_fixed_t *y)
452{
453 GLfloat xf, yf;
454
455 weston_surface_to_global_float(surface,
456 wl_fixed_to_double(sx),
457 wl_fixed_to_double(sy),
458 &xf, &yf);
459 *x = wl_fixed_from_double(xf);
460 *y = wl_fixed_from_double(yf);
461}
462
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200463static void
464surface_from_global_float(struct weston_surface *surface,
Daniel Stonebd3489b2012-05-08 17:17:53 +0100465 GLfloat x, GLfloat y, GLfloat *sx, GLfloat *sy)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200466{
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200467 if (surface->transform.enabled) {
468 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
469
470 weston_matrix_transform(&surface->transform.inverse, &v);
471
472 if (fabsf(v.f[3]) < 1e-6) {
Martin Minarik6d118362012-06-07 18:01:59 +0200473 weston_log("warning: numerical instability in "
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200474 "weston_surface_from_global(), divisor = %g\n",
475 v.f[3]);
476 *sx = 0;
477 *sy = 0;
478 return;
479 }
480
Pekka Paalanencd403622012-01-25 13:37:39 +0200481 *sx = v.f[0] / v.f[3];
482 *sy = v.f[1] / v.f[3];
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200483 } else {
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200484 *sx = x - surface->geometry.x;
485 *sy = y - surface->geometry.y;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200486 }
487}
488
489WL_EXPORT void
Daniel Stonebd3489b2012-05-08 17:17:53 +0100490weston_surface_from_global_fixed(struct weston_surface *surface,
491 wl_fixed_t x, wl_fixed_t y,
492 wl_fixed_t *sx, wl_fixed_t *sy)
493{
494 GLfloat sxf, syf;
495
Daniel Stonebd3489b2012-05-08 17:17:53 +0100496 surface_from_global_float(surface,
497 wl_fixed_to_double(x),
498 wl_fixed_to_double(y),
499 &sxf, &syf);
500 *sx = wl_fixed_from_double(sxf);
501 *sy = wl_fixed_from_double(syf);
502}
503
504WL_EXPORT void
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200505weston_surface_from_global(struct weston_surface *surface,
506 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
507{
508 GLfloat sxf, syf;
509
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200510 surface_from_global_float(surface, x, y, &sxf, &syf);
511 *sx = floorf(sxf);
512 *sy = floorf(syf);
513}
514
Tiago Vignatti9d393522012-02-10 16:26:19 +0200515static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500516weston_surface_damage_rectangle(struct weston_surface *surface,
Pekka Paalanen2267d452012-01-26 13:12:45 +0200517 int32_t sx, int32_t sy,
518 int32_t width, int32_t height)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500519{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200520 if (surface->transform.enabled) {
521 pixman_region32_t box;
522 surface_compute_bbox(surface, sx, sy, width, height, &box);
523 pixman_region32_union(&surface->damage, &surface->damage,
524 &box);
525 pixman_region32_fini(&box);
526 } else {
Pekka Paalanen2267d452012-01-26 13:12:45 +0200527 pixman_region32_union_rect(&surface->damage, &surface->damage,
Pekka Paalanen1d5035c2012-02-09 15:27:45 +0200528 surface->geometry.x + sx,
529 surface->geometry.y + sy,
530 width, height);
Pekka Paalanen2267d452012-01-26 13:12:45 +0200531 }
532
533 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500534}
535
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400536WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500537weston_surface_damage(struct weston_surface *surface)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500538{
Pekka Paalanen2267d452012-01-26 13:12:45 +0200539 pixman_region32_union(&surface->damage, &surface->damage,
540 &surface->transform.boundingbox);
541
542 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500543}
544
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400545WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500546weston_surface_configure(struct weston_surface *surface,
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200547 GLfloat x, GLfloat y, int width, int height)
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400548{
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200549 surface->geometry.x = x;
550 surface->geometry.y = y;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200551 surface->geometry.width = width;
552 surface->geometry.height = height;
Pekka Paalanencd403622012-01-25 13:37:39 +0200553 surface->geometry.dirty = 1;
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400554}
555
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +0200556WL_EXPORT void
557weston_surface_set_position(struct weston_surface *surface,
558 GLfloat x, GLfloat y)
559{
560 surface->geometry.x = x;
561 surface->geometry.y = y;
562 surface->geometry.dirty = 1;
563}
564
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300565WL_EXPORT int
566weston_surface_is_mapped(struct weston_surface *surface)
567{
568 if (surface->output)
569 return 1;
570 else
571 return 0;
572}
573
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400574WL_EXPORT uint32_t
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500575weston_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500576{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400577 struct timeval tv;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500578
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400579 gettimeofday(&tv, NULL);
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500580
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400581 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500582}
583
Tiago Vignatti9d393522012-02-10 16:26:19 +0200584static struct weston_surface *
585weston_compositor_pick_surface(struct weston_compositor *compositor,
Daniel Stone103db7f2012-05-08 17:17:55 +0100586 wl_fixed_t x, wl_fixed_t y,
587 wl_fixed_t *sx, wl_fixed_t *sy)
Tiago Vignatti9d393522012-02-10 16:26:19 +0200588{
589 struct weston_surface *surface;
590
591 wl_list_for_each(surface, &compositor->surface_list, link) {
Daniel Stone103db7f2012-05-08 17:17:55 +0100592 weston_surface_from_global_fixed(surface, x, y, sx, sy);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500593 if (pixman_region32_contains_point(&surface->input,
Daniel Stone103db7f2012-05-08 17:17:55 +0100594 wl_fixed_to_int(*sx),
595 wl_fixed_to_int(*sy),
596 NULL))
Tiago Vignatti9d393522012-02-10 16:26:19 +0200597 return surface;
598 }
599
600 return NULL;
601}
602
603static void
Daniel Stone37816df2012-05-16 18:45:18 +0100604weston_device_repick(struct wl_seat *seat)
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500605{
Daniel Stone37816df2012-05-16 18:45:18 +0100606 struct weston_seat *ws = (struct weston_seat *) seat;
Scott Moreau447013d2012-02-18 05:05:29 -0700607 const struct wl_pointer_grab_interface *interface;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500608 struct weston_surface *surface, *focus;
609
Daniel Stonee9e92d22012-06-04 11:40:47 +0100610 if (!seat->pointer)
611 return;
612
Daniel Stone37816df2012-05-16 18:45:18 +0100613 surface = weston_compositor_pick_surface(ws->compositor,
614 seat->pointer->x,
615 seat->pointer->y,
616 &seat->pointer->current_x,
617 &seat->pointer->current_y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500618
Daniel Stone37816df2012-05-16 18:45:18 +0100619 if (&surface->surface != seat->pointer->current) {
620 interface = seat->pointer->grab->interface;
Kristian Høgsberg4e99ac42012-06-04 16:12:38 -0400621 seat->pointer->current = &surface->surface;
Daniel Stone37816df2012-05-16 18:45:18 +0100622 interface->focus(seat->pointer->grab, &surface->surface,
623 seat->pointer->current_x,
624 seat->pointer->current_y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500625 }
626
Daniel Stone37816df2012-05-16 18:45:18 +0100627 focus = (struct weston_surface *) seat->pointer->grab->focus;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500628 if (focus)
Daniel Stone37816df2012-05-16 18:45:18 +0100629 weston_surface_from_global_fixed(focus,
630 seat->pointer->x,
631 seat->pointer->y,
632 &seat->pointer->grab->x,
633 &seat->pointer->grab->y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500634}
635
636WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500637weston_compositor_repick(struct weston_compositor *compositor)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400638{
Daniel Stone37816df2012-05-16 18:45:18 +0100639 struct weston_seat *seat;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400640
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500641 if (!compositor->focus)
642 return;
643
Daniel Stone37816df2012-05-16 18:45:18 +0100644 wl_list_for_each(seat, &compositor->seat_list, link)
645 weston_device_repick(&seat->seat);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400646}
647
648static void
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500649weston_surface_unmap(struct weston_surface *surface)
650{
Daniel Stone4dab5db2012-05-30 16:31:53 +0100651 struct weston_seat *seat;
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500652
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500653 weston_surface_damage_below(surface);
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500654 surface->output = NULL;
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500655 wl_list_remove(&surface->layer_link);
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500656
Daniel Stone4dab5db2012-05-30 16:31:53 +0100657 wl_list_for_each(seat, &surface->compositor->seat_list, link) {
Daniel Stonee9e92d22012-06-04 11:40:47 +0100658 if (seat->seat.keyboard &&
659 seat->seat.keyboard->focus == &surface->surface)
Daniel Stone4dab5db2012-05-30 16:31:53 +0100660 wl_keyboard_set_focus(seat->seat.keyboard, NULL);
Daniel Stonee9e92d22012-06-04 11:40:47 +0100661 if (seat->seat.pointer &&
662 seat->seat.pointer->focus == &surface->surface)
Daniel Stone4dab5db2012-05-30 16:31:53 +0100663 wl_pointer_set_focus(seat->seat.pointer,
664 NULL,
665 wl_fixed_from_int(0),
666 wl_fixed_from_int(0));
667 }
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500668
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500669 weston_compositor_schedule_repaint(surface->compositor);
670}
671
672static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400673destroy_surface(struct wl_resource *resource)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500674{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500675 struct weston_surface *surface =
676 container_of(resource,
677 struct weston_surface, surface.resource);
678 struct weston_compositor *compositor = surface->compositor;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400679
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300680 if (weston_surface_is_mapped(surface))
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500681 weston_surface_unmap(surface);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400682
Kristian Høgsberg12bbf812012-02-17 12:15:27 -0500683 if (surface->texture)
684 glDeleteTextures(1, &surface->texture);
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200685
Benjamin Franzke06286262011-05-06 19:12:33 +0200686 if (surface->buffer)
687 wl_list_remove(&surface->buffer_destroy_listener.link);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400688
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200689 if (surface->image != EGL_NO_IMAGE_KHR)
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400690 compositor->destroy_image(compositor->display,
691 surface->image);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200692
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200693 pixman_region32_fini(&surface->transform.boundingbox);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200694 pixman_region32_fini(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500695 pixman_region32_fini(&surface->opaque);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500696 pixman_region32_fini(&surface->clip);
Kristian Høgsbergdd631c12012-02-23 16:20:38 -0500697 if (!region_is_undefined(&surface->input))
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500698 pixman_region32_fini(&surface->input);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200699
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400700 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500701}
702
Alex Wu8811bf92012-02-28 18:07:54 +0800703WL_EXPORT void
704weston_surface_destroy(struct weston_surface *surface)
705{
706 /* Not a valid way to destroy a client surface */
707 assert(surface->surface.resource.client == NULL);
708
Kristian Høgsberg9a050af2012-06-07 18:17:42 -0400709 wl_signal_emit(&surface->surface.resource.destroy_signal,
710 &surface->surface.resource);
Alex Wu8811bf92012-02-28 18:07:54 +0800711 destroy_surface(&surface->surface.resource);
712}
713
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100714static void
Kristian Høgsberg8cbfb2a2012-03-27 17:04:59 -0400715weston_surface_attach(struct wl_surface *surface, struct wl_buffer *buffer)
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100716{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500717 struct weston_surface *es = (struct weston_surface *) surface;
718 struct weston_compositor *ec = es->compositor;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100719
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300720 if (es->buffer) {
721 weston_buffer_post_release(es->buffer);
722 wl_list_remove(&es->buffer_destroy_listener.link);
723 }
724
725 es->buffer = buffer;
726
727 if (!buffer) {
728 if (weston_surface_is_mapped(es))
729 weston_surface_unmap(es);
730 return;
731 }
732
733 buffer->busy_count++;
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400734 wl_signal_add(&es->buffer->resource.destroy_signal,
735 &es->buffer_destroy_listener);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300736
737 if (es->geometry.width != buffer->width ||
738 es->geometry.height != buffer->height) {
739 undef_region(&es->input);
740 pixman_region32_fini(&es->opaque);
741 pixman_region32_init(&es->opaque);
742 }
743
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500744 if (!es->texture) {
745 glGenTextures(1, &es->texture);
746 glBindTexture(GL_TEXTURE_2D, es->texture);
747 glTexParameteri(GL_TEXTURE_2D,
748 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
749 glTexParameteri(GL_TEXTURE_2D,
750 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
751 es->shader = &ec->texture_shader;
752 } else {
753 glBindTexture(GL_TEXTURE_2D, es->texture);
754 }
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100755
756 if (wl_buffer_is_shm(buffer)) {
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200757 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
Kristian Høgsbergfb6de222012-03-27 17:10:13 -0400758 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
759 es->pitch, es->buffer->height, 0,
760 GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400761 if (wl_shm_buffer_get_format(buffer) == WL_SHM_FORMAT_XRGB8888)
762 es->blend = 0;
763 else
764 es->blend = 1;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100765 } else {
Benjamin Franzkefb4b5a22011-06-21 10:44:37 +0200766 if (es->image != EGL_NO_IMAGE_KHR)
767 ec->destroy_image(ec->display, es->image);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400768 es->image = ec->create_image(ec->display, NULL,
769 EGL_WAYLAND_BUFFER_WL,
770 buffer, NULL);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300771
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400772 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400773
Ander Conselvan de Oliveira9390ae32012-03-27 17:36:38 +0300774 es->pitch = buffer->width;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100775 }
776}
777
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400778static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500779texture_region(struct weston_surface *es, pixman_region32_t *region)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500780{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500781 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500782 GLfloat *v, inv_width, inv_height;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200783 GLfloat sx, sy;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500784 pixman_box32_t *rectangles;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400785 unsigned int *p;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500786 int i, n;
787
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400788 rectangles = pixman_region32_rectangles(region, &n);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500789 v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
790 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200791 inv_width = 1.0 / es->pitch;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200792 inv_height = 1.0 / es->geometry.height;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400793
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500794 for (i = 0; i < n; i++, v += 16, p += 6) {
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200795 surface_from_global_float(es, rectangles[i].x1,
796 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500797 v[ 0] = rectangles[i].x1;
798 v[ 1] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200799 v[ 2] = sx * inv_width;
800 v[ 3] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500801
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200802 surface_from_global_float(es, rectangles[i].x1,
803 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500804 v[ 4] = rectangles[i].x1;
805 v[ 5] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200806 v[ 6] = sx * inv_width;
807 v[ 7] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500808
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200809 surface_from_global_float(es, rectangles[i].x2,
810 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500811 v[ 8] = rectangles[i].x2;
812 v[ 9] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200813 v[10] = sx * inv_width;
814 v[11] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500815
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200816 surface_from_global_float(es, rectangles[i].x2,
817 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500818 v[12] = rectangles[i].x2;
819 v[13] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200820 v[14] = sx * inv_width;
821 v[15] = sy * inv_height;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500822
823 p[0] = i * 4 + 0;
824 p[1] = i * 4 + 1;
825 p[2] = i * 4 + 2;
826 p[3] = i * 4 + 2;
827 p[4] = i * 4 + 1;
828 p[5] = i * 4 + 3;
829 }
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500830
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400831 return n;
832}
833
Kristian Høgsberg68c479a2012-01-25 23:32:28 -0500834WL_EXPORT void
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500835weston_surface_draw(struct weston_surface *es, struct weston_output *output,
836 pixman_region32_t *damage)
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400837{
Scott Moreau9fb98242012-05-22 10:18:50 -0600838 GLfloat surface_rect[4] = { 0.0, 1.0, 0.0, 1.0 };
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500839 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400840 GLfloat *v;
841 pixman_region32_t repaint;
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400842 GLint filter;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400843 int n;
844
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200845 pixman_region32_init(&repaint);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500846 pixman_region32_intersect(&repaint,
847 &es->transform.boundingbox, damage);
848 pixman_region32_subtract(&repaint, &repaint, &es->clip);
Pekka Paalanenc7b45f62012-02-06 12:16:07 +0200849
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400850 if (!pixman_region32_not_empty(&repaint))
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200851 goto out;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400852
Kristian Høgsberg101cb652012-02-17 10:45:16 -0500853 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
Scott Moreau9fb98242012-05-22 10:18:50 -0600854 if (es->blend || es->alpha < 1.0)
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400855 glEnable(GL_BLEND);
856 else
857 glDisable(GL_BLEND);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400858
Kristian Høgsberg07632622012-01-25 23:02:06 -0500859 if (ec->current_shader != es->shader) {
860 glUseProgram(es->shader->program);
Kristian Høgsberg07632622012-01-25 23:02:06 -0500861 ec->current_shader = es->shader;
862 }
863
Kristian Høgsberg0452abc2012-01-31 15:38:36 -0500864 glUniformMatrix4fv(es->shader->proj_uniform,
865 1, GL_FALSE, output->matrix.d);
Pekka Paalanenf55f5442012-02-02 16:49:05 +0200866 glUniform1i(es->shader->tex_uniform, 0);
867 glUniform4fv(es->shader->color_uniform, 1, es->color);
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400868 glUniform1f(es->shader->alpha_uniform, es->alpha);
Pekka Paalanenf55f5442012-02-02 16:49:05 +0200869 glUniform1f(es->shader->texwidth_uniform,
870 (GLfloat)es->geometry.width / es->pitch);
Scott Moreau9fb98242012-05-22 10:18:50 -0600871 if (es->blend)
872 glUniform4fv(es->shader->opaque_uniform, 1, es->opaque_rect);
873 else
874 glUniform4fv(es->shader->opaque_uniform, 1, surface_rect);
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200875
Scott Moreauccbf29d2012-02-22 14:21:41 -0700876 if (es->transform.enabled || output->zoom.active)
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400877 filter = GL_LINEAR;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200878 else
Pekka Paalanenc61eca62012-01-06 14:10:06 +0200879 filter = GL_NEAREST;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200880
881 n = texture_region(es, &repaint);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400882
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500883 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400884 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
885 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
886
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500887 v = ec->vertices.data;
888 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
889 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400890 glEnableVertexAttribArray(0);
891 glEnableVertexAttribArray(1);
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200892
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500893 glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
894
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200895 glDisableVertexAttribArray(1);
896 glDisableVertexAttribArray(0);
897
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500898 ec->vertices.size = 0;
899 ec->indices.size = 0;
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200900
901out:
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500902 pixman_region32_fini(&repaint);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500903}
904
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500905WL_EXPORT void
906weston_surface_restack(struct weston_surface *surface, struct wl_list *below)
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400907{
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500908 wl_list_remove(&surface->layer_link);
909 wl_list_insert(below, &surface->layer_link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500910 weston_surface_damage_below(surface);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500911 weston_surface_damage(surface);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400912}
913
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400914WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500915weston_compositor_damage_all(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400916{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500917 struct weston_output *output;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400918
919 wl_list_for_each(output, &compositor->output_list, link)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500920 weston_output_damage(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400921}
922
Kristian Høgsberg9f404b72012-01-26 00:11:01 -0500923WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500924weston_buffer_post_release(struct wl_buffer *buffer)
Benjamin Franzke06286262011-05-06 19:12:33 +0200925{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400926 if (--buffer->busy_count > 0)
Benjamin Franzke06286262011-05-06 19:12:33 +0200927 return;
Benjamin Franzke06286262011-05-06 19:12:33 +0200928
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400929 assert(buffer->resource.client != NULL);
Kristian Høgsbergeccef6a2011-11-17 16:46:19 -0500930 wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
Benjamin Franzke06286262011-05-06 19:12:33 +0200931}
932
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400933WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500934weston_output_damage(struct weston_output *output)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400935{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500936 struct weston_compositor *compositor = output->compositor;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400937
Kristian Høgsberg944236a2012-02-28 23:07:47 -0500938 pixman_region32_union(&compositor->damage,
939 &compositor->damage, &output->region);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500940 weston_compositor_schedule_repaint(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400941}
942
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400943static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500944fade_frame(struct weston_animation *animation,
945 struct weston_output *output, uint32_t msecs)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400946{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500947 struct weston_compositor *compositor =
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400948 container_of(animation,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500949 struct weston_compositor, fade.animation);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500950 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400951
Scott Moreau94b0b0c2012-06-14 01:01:56 -0600952 if (animation->frame_counter <= 1)
Scott Moreaue2949db2012-06-11 13:09:23 -0600953 compositor->fade.spring.timestamp = msecs;
954
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500955 surface = compositor->fade.surface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500956 weston_spring_update(&compositor->fade.spring, msecs);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500957 weston_surface_set_color(surface, 0.0, 0.0, 0.0,
958 compositor->fade.spring.current);
959 weston_surface_damage(surface);
960
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500961 if (weston_spring_done(&compositor->fade.spring)) {
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400962 compositor->fade.spring.current =
963 compositor->fade.spring.target;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400964 wl_list_remove(&animation->link);
965 wl_list_init(&animation->link);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200966
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500967 if (compositor->fade.spring.current < 0.001) {
968 destroy_surface(&surface->surface.resource);
969 compositor->fade.surface = NULL;
970 } else if (compositor->fade.spring.current > 0.999) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500971 compositor->state = WESTON_COMPOSITOR_SLEEPING;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -0400972 wl_signal_emit(&compositor->lock_signal, compositor);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200973 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400974 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400975}
976
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500977struct weston_frame_callback {
978 struct wl_resource resource;
979 struct wl_list link;
980};
981
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400982static void
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500983weston_output_repaint(struct weston_output *output, int msecs)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400984{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500985 struct weston_compositor *ec = output->compositor;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -0500986 struct weston_surface *es;
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500987 struct weston_layer *layer;
Kristian Høgsberg30c018b2012-01-26 08:40:37 -0500988 struct weston_animation *animation, *next;
989 struct weston_frame_callback *cb, *cnext;
Jonas Ådahldb773762012-06-13 00:01:21 +0200990 struct wl_list frame_callback_list;
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500991 pixman_region32_t opaque, new_damage, output_damage;
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500992 int32_t width, height;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500993
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +0200994 weston_compositor_update_drag_surfaces(ec);
995
Kristian Høgsberg546a8122012-02-01 07:45:51 -0500996 width = output->current->width +
997 output->border.left + output->border.right;
998 height = output->current->height +
999 output->border.top + output->border.bottom;
1000 glViewport(0, 0, width, height);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -05001001
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001002 /* Rebuild the surface list and update surface transforms up front. */
1003 wl_list_init(&ec->surface_list);
Jonas Ådahldb773762012-06-13 00:01:21 +02001004 wl_list_init(&frame_callback_list);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001005 wl_list_for_each(layer, &ec->layer_list, link) {
1006 wl_list_for_each(es, &layer->surface_list, layer_link) {
1007 weston_surface_update_transform(es);
1008 wl_list_insert(ec->surface_list.prev, &es->link);
Jonas Ådahldb773762012-06-13 00:01:21 +02001009 if (es->output == output) {
1010 wl_list_insert_list(&frame_callback_list,
1011 &es->frame_callback_list);
1012 wl_list_init(&es->frame_callback_list);
1013 }
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001014 }
1015 }
Pekka Paalanen15d60ef2012-01-27 14:38:33 +02001016
Jesse Barnes5308a5e2012-02-09 13:12:57 -08001017 if (output->assign_planes)
1018 /*
1019 * This will queue flips for the fbs and sprites where
1020 * applicable and clear the damage for those surfaces.
1021 * The repaint loop below will repaint everything
1022 * else.
1023 */
1024 output->assign_planes(output);
1025
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001026 pixman_region32_init(&new_damage);
1027 pixman_region32_init(&opaque);
1028
Kristian Høgsberga82c4862012-01-26 01:03:58 -05001029 wl_list_for_each(es, &ec->surface_list, link) {
1030 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
1031 pixman_region32_union(&new_damage, &new_damage, &es->damage);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001032 empty_region(&es->damage);
1033 pixman_region32_copy(&es->clip, &opaque);
Pekka Paalanen730d87e2012-02-09 16:39:38 +02001034 pixman_region32_union(&opaque, &opaque, &es->transform.opaque);
Kristian Høgsberga82c4862012-01-26 01:03:58 -05001035 }
1036
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001037 pixman_region32_union(&ec->damage, &ec->damage, &new_damage);
1038
1039 pixman_region32_init(&output_damage);
1040 pixman_region32_union(&output_damage,
1041 &ec->damage, &output->previous_damage);
1042 pixman_region32_copy(&output->previous_damage, &ec->damage);
1043 pixman_region32_intersect(&output_damage,
1044 &output_damage, &output->region);
1045 pixman_region32_subtract(&ec->damage, &ec->damage, &output->region);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001046
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -04001047 pixman_region32_fini(&opaque);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -04001048 pixman_region32_fini(&new_damage);
1049
Scott Moreauccbf29d2012-02-22 14:21:41 -07001050 if (output->dirty)
1051 weston_output_update_matrix(output);
1052
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001053 output->repaint(output, &output_damage);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001054
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001055 pixman_region32_fini(&output_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001056
Kristian Høgsbergef044142011-06-21 15:02:12 -04001057 output->repaint_needed = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001058
Kristian Høgsbergaa6019e2012-03-11 16:35:16 -04001059 weston_compositor_repick(ec);
1060 wl_event_loop_dispatch(ec->input_loop, 0);
1061
Jonas Ådahldb773762012-06-13 00:01:21 +02001062 wl_list_for_each_safe(cb, cnext, &frame_callback_list, link) {
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05001063 wl_callback_send_done(&cb->resource, msecs);
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001064 wl_resource_destroy(&cb->resource);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001065 }
Jonas Ådahldb773762012-06-13 00:01:21 +02001066 wl_list_init(&frame_callback_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001067
Scott Moreaud64cf212012-06-08 19:40:54 -06001068 wl_list_for_each_safe(animation, next, &output->animation_list, link) {
Scott Moreaud64cf212012-06-08 19:40:54 -06001069 animation->frame_counter++;
Scott Moreau94b0b0c2012-06-14 01:01:56 -06001070 animation->frame(animation, output, msecs);
Scott Moreaud64cf212012-06-08 19:40:54 -06001071 }
Kristian Høgsbergef044142011-06-21 15:02:12 -04001072}
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001073
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001074static int
1075weston_compositor_read_input(int fd, uint32_t mask, void *data)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001076{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001077 struct weston_compositor *compositor = data;
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05001078
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001079 wl_event_loop_dispatch(compositor->input_loop, 0);
1080
1081 return 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001082}
1083
1084WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001085weston_output_finish_frame(struct weston_output *output, int msecs)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001086{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001087 struct weston_compositor *compositor = output->compositor;
1088 struct wl_event_loop *loop =
1089 wl_display_get_event_loop(compositor->wl_display);
1090 int fd;
1091
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -04001092 wl_signal_emit(&output->frame_signal, &msecs);
1093
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001094 if (output->repaint_needed) {
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001095 weston_output_repaint(output, msecs);
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001096 return;
1097 }
1098
1099 output->repaint_scheduled = 0;
1100 if (compositor->input_loop_source)
1101 return;
1102
1103 fd = wl_event_loop_get_fd(compositor->input_loop);
1104 compositor->input_loop_source =
1105 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
1106 weston_compositor_read_input, compositor);
1107}
1108
1109static void
1110idle_repaint(void *data)
1111{
1112 struct weston_output *output = data;
1113
1114 weston_output_finish_frame(output, weston_compositor_get_time());
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001115}
1116
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001117WL_EXPORT void
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001118weston_layer_init(struct weston_layer *layer, struct wl_list *below)
1119{
1120 wl_list_init(&layer->surface_list);
Jonas Ådahle3cddce2012-06-13 00:01:22 +02001121 if (below != NULL)
1122 wl_list_insert(below, &layer->link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001123}
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{
Scott Moreau9d1b1122012-06-08 19:40:53 -06001153 struct weston_output *output;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001154 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001155
Scott Moreau9d1b1122012-06-08 19:40:53 -06001156 output = container_of(compositor->output_list.next,
1157 struct weston_output, link);
1158
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001159 compositor->fade.spring.target = tint;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001160 if (weston_spring_done(&compositor->fade.spring))
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001161 return;
1162
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001163 if (compositor->fade.surface == NULL) {
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001164 surface = weston_surface_create(compositor);
1165 weston_surface_configure(surface, 0, 0, 8192, 8192);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001166 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001167 wl_list_insert(&compositor->fade_layer.surface_list,
1168 &surface->layer_link);
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02001169 weston_surface_assign_output(surface);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001170 compositor->fade.surface = surface;
Kristian Høgsberg9bc70952012-02-29 12:22:38 -05001171 pixman_region32_init(&surface->input);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001172 }
1173
1174 weston_surface_damage(compositor->fade.surface);
Scott Moreaud64cf212012-06-08 19:40:54 -06001175 if (wl_list_empty(&compositor->fade.animation.link)) {
1176 compositor->fade.animation.frame_counter = 0;
Scott Moreau9d1b1122012-06-08 19:40:53 -06001177 wl_list_insert(output->animation_list.prev,
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001178 &compositor->fade.animation.link);
Scott Moreaud64cf212012-06-08 19:40:54 -06001179 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001180}
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);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001261}
1262
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001263static void
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001264surface_attach(struct wl_client *client,
1265 struct wl_resource *resource,
1266 struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
1267{
1268 struct weston_surface *es = resource->data;
1269 struct wl_buffer *buffer = NULL;
1270
1271 if (buffer_resource)
1272 buffer = buffer_resource->data;
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001273
Kristian Høgsberg8cbfb2a2012-03-27 17:04:59 -04001274 weston_surface_attach(&es->surface, buffer);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001275
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03001276 if (buffer && es->configure)
1277 es->configure(es, sx, sy);
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001278}
1279
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001280static void
Pekka Paalanen52bfbaa2012-04-11 16:19:37 +03001281texture_set_subimage(struct weston_surface *surface,
1282 int32_t x, int32_t y, int32_t width, int32_t height)
1283{
1284 glBindTexture(GL_TEXTURE_2D, surface->texture);
1285
1286#ifdef GL_UNPACK_ROW_LENGTH
1287 /* Mesa does not define GL_EXT_unpack_subimage */
1288
1289 if (surface->compositor->has_unpack_subimage) {
1290 glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->pitch);
1291 glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
1292 glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
1293
1294 glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height,
1295 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1296 wl_shm_buffer_get_data(surface->buffer));
1297 return;
1298 }
1299#endif
1300
1301 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
1302 surface->pitch, surface->buffer->height, 0,
1303 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1304 wl_shm_buffer_get_data(surface->buffer));
1305}
1306
1307static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001308surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001309 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001310 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -05001311{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001312 struct weston_surface *es = resource->data;
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -04001313
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001314 weston_surface_damage_rectangle(es, x, y, width, height);
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04001315
Pekka Paalanen52bfbaa2012-04-11 16:19:37 +03001316 if (es->buffer && wl_buffer_is_shm(es->buffer))
1317 texture_set_subimage(es, x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001318}
1319
Kristian Høgsberg33418202011-08-16 23:01:28 -04001320static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001321destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001322{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001323 struct weston_frame_callback *cb = resource->data;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001324
1325 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02001326 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001327}
1328
1329static void
1330surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001331 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001332{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001333 struct weston_frame_callback *cb;
1334 struct weston_surface *es = resource->data;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001335
1336 cb = malloc(sizeof *cb);
1337 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001338 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001339 return;
1340 }
1341
1342 cb->resource.object.interface = &wl_callback_interface;
1343 cb->resource.object.id = callback;
1344 cb->resource.destroy = destroy_frame_callback;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001345 cb->resource.client = client;
1346 cb->resource.data = cb;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001347
1348 wl_client_add_resource(client, &cb->resource);
Jonas Ådahldb773762012-06-13 00:01:21 +02001349 wl_list_insert(es->frame_callback_list.prev, &cb->link);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001350}
1351
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001352static void
1353surface_set_opaque_region(struct wl_client *client,
1354 struct wl_resource *resource,
1355 struct wl_resource *region_resource)
1356{
1357 struct weston_surface *surface = resource->data;
1358 struct weston_region *region;
1359
1360 pixman_region32_fini(&surface->opaque);
1361
1362 if (region_resource) {
1363 region = region_resource->data;
1364 pixman_region32_init_rect(&surface->opaque, 0, 0,
1365 surface->geometry.width,
1366 surface->geometry.height);
1367 pixman_region32_intersect(&surface->opaque,
1368 &surface->opaque, &region->region);
1369 } else {
1370 pixman_region32_init(&surface->opaque);
1371 }
1372
1373 surface->geometry.dirty = 1;
1374}
1375
1376static void
1377surface_set_input_region(struct wl_client *client,
1378 struct wl_resource *resource,
1379 struct wl_resource *region_resource)
1380{
1381 struct weston_surface *surface = resource->data;
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05001382 struct weston_region *region;
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001383
1384 if (region_resource) {
1385 region = region_resource->data;
1386 pixman_region32_init_rect(&surface->input, 0, 0,
1387 surface->geometry.width,
1388 surface->geometry.height);
1389 pixman_region32_intersect(&surface->input,
1390 &surface->input, &region->region);
1391 } else {
1392 pixman_region32_init_rect(&surface->input, 0, 0,
1393 surface->geometry.width,
1394 surface->geometry.height);
1395 }
1396
Kristian Høgsbergaa6019e2012-03-11 16:35:16 -04001397 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001398}
1399
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001400static const struct wl_surface_interface surface_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001401 surface_destroy,
1402 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04001403 surface_damage,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001404 surface_frame,
1405 surface_set_opaque_region,
1406 surface_set_input_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001407};
1408
1409static void
1410compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001411 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001412{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001413 struct weston_compositor *ec = resource->data;
1414 struct weston_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001415
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001416 surface = weston_surface_create(ec);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001417 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001418 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001419 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001420 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001421
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001422 surface->surface.resource.destroy = destroy_surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001423
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001424 surface->surface.resource.object.id = id;
1425 surface->surface.resource.object.interface = &wl_surface_interface;
1426 surface->surface.resource.object.implementation =
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001427 (void (**)(void)) &surface_interface;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001428 surface->surface.resource.data = surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001429
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001430 wl_client_add_resource(client, &surface->surface.resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001431}
1432
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001433static void
1434destroy_region(struct wl_resource *resource)
1435{
1436 struct weston_region *region =
1437 container_of(resource, struct weston_region, resource);
1438
1439 pixman_region32_fini(&region->region);
1440 free(region);
1441}
1442
1443static void
1444region_destroy(struct wl_client *client, struct wl_resource *resource)
1445{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001446 wl_resource_destroy(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001447}
1448
1449static void
1450region_add(struct wl_client *client, struct wl_resource *resource,
1451 int32_t x, int32_t y, int32_t width, int32_t height)
1452{
1453 struct weston_region *region = resource->data;
1454
1455 pixman_region32_union_rect(&region->region, &region->region,
1456 x, y, width, height);
1457}
1458
1459static void
1460region_subtract(struct wl_client *client, struct wl_resource *resource,
1461 int32_t x, int32_t y, int32_t width, int32_t height)
1462{
1463 struct weston_region *region = resource->data;
1464 pixman_region32_t rect;
1465
1466 pixman_region32_init_rect(&rect, x, y, width, height);
1467 pixman_region32_subtract(&region->region, &region->region, &rect);
1468 pixman_region32_fini(&rect);
1469}
1470
1471static const struct wl_region_interface region_interface = {
1472 region_destroy,
1473 region_add,
1474 region_subtract
1475};
1476
1477static void
1478compositor_create_region(struct wl_client *client,
1479 struct wl_resource *resource, uint32_t id)
1480{
1481 struct weston_region *region;
1482
1483 region = malloc(sizeof *region);
1484 if (region == NULL) {
1485 wl_resource_post_no_memory(resource);
1486 return;
1487 }
1488
1489 region->resource.destroy = destroy_region;
1490
1491 region->resource.object.id = id;
1492 region->resource.object.interface = &wl_region_interface;
1493 region->resource.object.implementation =
1494 (void (**)(void)) &region_interface;
1495 region->resource.data = region;
1496
1497 pixman_region32_init(&region->region);
1498
1499 wl_client_add_resource(client, &region->resource);
1500}
1501
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001502static const struct wl_compositor_interface compositor_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001503 compositor_create_surface,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001504 compositor_create_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001505};
1506
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001507WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001508weston_compositor_wake(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001509{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001510 compositor->state = WESTON_COMPOSITOR_ACTIVE;
1511 weston_compositor_fade(compositor, 0.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001512
1513 wl_event_source_timer_update(compositor->idle_source,
Pekka Paalanen7296e792011-12-07 16:22:00 +02001514 compositor->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001515}
1516
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001517static void
1518weston_compositor_dpms_on(struct weston_compositor *compositor)
1519{
1520 struct weston_output *output;
1521
1522 wl_list_for_each(output, &compositor->output_list, link)
1523 if (output->set_dpms)
1524 output->set_dpms(output, WESTON_DPMS_ON);
1525}
1526
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001527WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001528weston_compositor_activity(struct weston_compositor *compositor)
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001529{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001530 if (compositor->state == WESTON_COMPOSITOR_ACTIVE) {
1531 weston_compositor_wake(compositor);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001532 } else {
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001533 weston_compositor_dpms_on(compositor);
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001534 wl_signal_emit(&compositor->unlock_signal, compositor);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001535 }
1536}
1537
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001538static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001539weston_compositor_idle_inhibit(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001540{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001541 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001542 compositor->idle_inhibit++;
1543}
1544
1545static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001546weston_compositor_idle_release(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001547{
1548 compositor->idle_inhibit--;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001549 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001550}
1551
1552static int
1553idle_handler(void *data)
1554{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001555 struct weston_compositor *compositor = data;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001556
1557 if (compositor->idle_inhibit)
1558 return 1;
1559
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001560 weston_compositor_fade(compositor, 1.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001561
1562 return 1;
1563}
1564
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001565static void
Daniel Stone37816df2012-05-16 18:45:18 +01001566weston_seat_update_drag_surface(struct wl_seat *seat, int dx, int dy);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001567
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001568static void
Daniel Stone37816df2012-05-16 18:45:18 +01001569clip_pointer_motion(struct weston_seat *seat, wl_fixed_t *fx, wl_fixed_t *fy)
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001570{
Daniel Stone37816df2012-05-16 18:45:18 +01001571 struct weston_compositor *ec = seat->compositor;
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001572 struct weston_output *output, *prev = NULL;
1573 int x, y, old_x, old_y, valid = 0;
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001574
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001575 x = wl_fixed_to_int(*fx);
1576 y = wl_fixed_to_int(*fy);
Daniel Stone37816df2012-05-16 18:45:18 +01001577 old_x = wl_fixed_to_int(seat->seat.pointer->x);
1578 old_y = wl_fixed_to_int(seat->seat.pointer->y);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001579
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001580 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001581 if (pixman_region32_contains_point(&output->region,
1582 x, y, NULL))
1583 valid = 1;
1584 if (pixman_region32_contains_point(&output->region,
1585 old_x, old_y, NULL))
1586 prev = output;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001587 }
Daniel Stone37816df2012-05-16 18:45:18 +01001588
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001589 if (!valid) {
1590 if (x < prev->x)
1591 *fx = wl_fixed_from_int(prev->x);
1592 else if (x >= prev->x + prev->current->width)
1593 *fx = wl_fixed_from_int(prev->x +
1594 prev->current->width - 1);
1595 if (y < prev->y)
1596 *fy = wl_fixed_from_int(prev->y);
1597 else if (y >= prev->y + prev->current->height)
1598 *fy = wl_fixed_from_int(prev->y +
1599 prev->current->height - 1);
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001600 }
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001601}
1602
1603WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001604notify_motion(struct wl_seat *seat, uint32_t time, wl_fixed_t x, wl_fixed_t y)
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001605{
1606 const struct wl_pointer_grab_interface *interface;
Daniel Stone37816df2012-05-16 18:45:18 +01001607 struct weston_seat *ws = (struct weston_seat *) seat;
1608 struct weston_compositor *ec = ws->compositor;
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001609 struct weston_output *output;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001610 int32_t ix, iy;
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001611
1612 weston_compositor_activity(ec);
1613
Daniel Stone37816df2012-05-16 18:45:18 +01001614 clip_pointer_motion(ws, &x, &y);
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001615
Daniel Stone37816df2012-05-16 18:45:18 +01001616 weston_seat_update_drag_surface(seat,
1617 x - seat->pointer->x,
1618 y - seat->pointer->y);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001619
Daniel Stone37816df2012-05-16 18:45:18 +01001620 seat->pointer->x = x;
1621 seat->pointer->y = y;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001622
1623 ix = wl_fixed_to_int(x);
1624 iy = wl_fixed_to_int(y);
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -05001625
Scott Moreauccbf29d2012-02-22 14:21:41 -07001626 wl_list_for_each(output, &ec->output_list, link)
1627 if (output->zoom.active &&
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001628 pixman_region32_contains_point(&output->region,
1629 ix, iy, NULL))
Scott Moreau8dacaab2012-06-17 18:10:58 -06001630 weston_output_update_zoom(output, ZOOM_FOCUS_POINTER);
Scott Moreauccbf29d2012-02-22 14:21:41 -07001631
Daniel Stone37816df2012-05-16 18:45:18 +01001632 weston_device_repick(seat);
1633 interface = seat->pointer->grab->interface;
1634 interface->motion(seat->pointer->grab, time,
1635 seat->pointer->grab->x, seat->pointer->grab->y);
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001636
Daniel Stone37816df2012-05-16 18:45:18 +01001637 if (ws->sprite) {
1638 weston_surface_set_position(ws->sprite,
1639 ix - ws->hotspot_x,
1640 iy - ws->hotspot_y);
Pekka Paalanenf8c6aae2012-02-13 11:01:59 +02001641 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001642 }
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001643}
1644
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001645WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001646weston_surface_activate(struct weston_surface *surface,
Daniel Stone37816df2012-05-16 18:45:18 +01001647 struct weston_seat *seat)
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001648{
Daniel Stone37816df2012-05-16 18:45:18 +01001649 struct weston_compositor *compositor = seat->compositor;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001650
Pekka Paalanenbdc7cd02012-06-07 15:07:07 +03001651 if (seat->seat.keyboard) {
1652 wl_keyboard_set_focus(seat->seat.keyboard, &surface->surface);
1653 wl_data_device_set_keyboard_focus(&seat->seat);
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001654
Pekka Paalanenbdc7cd02012-06-07 15:07:07 +03001655 if (seat->seat.keyboard->focus_resource) {
1656 wl_keyboard_send_modifiers(
1657 seat->seat.keyboard->focus_resource,
1658 wl_display_next_serial(compositor->wl_display),
1659 seat->xkb_state.mods_depressed,
1660 seat->xkb_state.mods_latched,
1661 seat->xkb_state.mods_locked,
1662 seat->xkb_state.group);
1663 }
Daniel Stone351eb612012-05-31 15:27:47 -04001664 }
1665
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001666 wl_signal_emit(&compositor->activate_signal, surface);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001667}
1668
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001669WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001670notify_button(struct wl_seat *seat, uint32_t time, int32_t button,
Daniel Stone4dbadb12012-05-30 16:31:51 +01001671 enum wl_pointer_button_state state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001672{
Daniel Stone37816df2012-05-16 18:45:18 +01001673 struct weston_seat *ws = (struct weston_seat *) seat;
1674 struct weston_compositor *compositor = ws->compositor;
1675 struct weston_surface *focus =
1676 (struct weston_surface *) seat->pointer->focus;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001677 uint32_t serial = wl_display_next_serial(compositor->wl_display);
Kristian Høgsbergea081152010-12-07 08:59:51 -05001678
Daniel Stone4dbadb12012-05-30 16:31:51 +01001679 if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
Scott Moreauff1db4a2012-04-17 19:06:18 -06001680 if (compositor->ping_handler && focus)
1681 compositor->ping_handler(focus, serial);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001682 weston_compositor_idle_inhibit(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001683 if (seat->pointer->button_count == 0) {
1684 seat->pointer->grab_button = button;
1685 seat->pointer->grab_time = time;
1686 seat->pointer->grab_x = seat->pointer->x;
1687 seat->pointer->grab_y = seat->pointer->y;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001688 }
Daniel Stone37816df2012-05-16 18:45:18 +01001689 seat->pointer->button_count++;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001690 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001691 weston_compositor_idle_release(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001692 seat->pointer->button_count--;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001693 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001694
Daniel Stone325fc2d2012-05-30 16:31:58 +01001695 weston_compositor_run_button_binding(compositor, ws, time, button,
1696 state);
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001697
Daniel Stone37816df2012-05-16 18:45:18 +01001698 seat->pointer->grab->interface->button(seat->pointer->grab, time,
1699 button, state);
Kristian Høgsberg5a5f0072011-12-19 14:54:11 -05001700
Daniel Stone37816df2012-05-16 18:45:18 +01001701 if (seat->pointer->button_count == 1)
1702 seat->pointer->grab_serial =
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001703 wl_display_get_serial(compositor->wl_display);
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001704}
1705
Scott Moreau210d0792012-03-22 10:47:01 -06001706WL_EXPORT void
Daniel Stone878f0b72012-05-30 16:31:57 +01001707notify_axis(struct wl_seat *seat, uint32_t time, uint32_t axis,
1708 wl_fixed_t value)
Scott Moreau210d0792012-03-22 10:47:01 -06001709{
Daniel Stone37816df2012-05-16 18:45:18 +01001710 struct weston_seat *ws = (struct weston_seat *) seat;
1711 struct weston_compositor *compositor = ws->compositor;
1712 struct weston_surface *focus =
1713 (struct weston_surface *) seat->pointer->focus;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001714 uint32_t serial = wl_display_next_serial(compositor->wl_display);
1715
1716 if (compositor->ping_handler && focus)
1717 compositor->ping_handler(focus, serial);
Scott Moreau210d0792012-03-22 10:47:01 -06001718
1719 weston_compositor_activity(compositor);
1720
Scott Moreau6a3633d2012-03-20 08:47:59 -06001721 if (value)
Daniel Stone325fc2d2012-05-30 16:31:58 +01001722 weston_compositor_run_axis_binding(compositor, ws, time, axis,
Daniel Stone0c1e46e2012-05-30 16:31:59 +01001723 value);
Scott Moreau6a3633d2012-03-20 08:47:59 -06001724 else
1725 return;
1726
Daniel Stone37816df2012-05-16 18:45:18 +01001727 if (seat->pointer->focus_resource)
Daniel Stone878f0b72012-05-30 16:31:57 +01001728 wl_pointer_send_axis(seat->pointer->focus_resource, time, axis,
Daniel Stone2fce4022012-05-30 16:32:00 +01001729 value);
Scott Moreau210d0792012-03-22 10:47:01 -06001730}
1731
Daniel Stone7ace3902012-05-30 16:31:40 +01001732static int
Daniel Stone37816df2012-05-16 18:45:18 +01001733update_modifier_state(struct weston_seat *seat, uint32_t key, uint32_t state)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001734{
Daniel Stone7ace3902012-05-30 16:31:40 +01001735 uint32_t mods_depressed, mods_latched, mods_locked, group;
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001736 uint32_t mods_lookup;
Daniel Stone8c8164f2012-05-30 16:31:45 +01001737 enum weston_led leds = 0;
Daniel Stone7ace3902012-05-30 16:31:40 +01001738 int ret = 0;
1739
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001740 /* First update the XKB state object with the keypress. */
Daniel Stone994679a2012-05-30 16:31:43 +01001741 xkb_state_update_key(seat->xkb_state.state, key + 8,
Daniel Stone7ace3902012-05-30 16:31:40 +01001742 state ? XKB_KEY_DOWN : XKB_KEY_UP);
1743
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001744 /* Serialize and update our internal state, checking to see if it's
1745 * different to the previous state. */
Daniel Stone994679a2012-05-30 16:31:43 +01001746 mods_depressed = xkb_state_serialize_mods(seat->xkb_state.state,
1747 XKB_STATE_DEPRESSED);
1748 mods_latched = xkb_state_serialize_mods(seat->xkb_state.state,
1749 XKB_STATE_LATCHED);
1750 mods_locked = xkb_state_serialize_mods(seat->xkb_state.state,
1751 XKB_STATE_LOCKED);
1752 group = xkb_state_serialize_group(seat->xkb_state.state,
Daniel Stone7ace3902012-05-30 16:31:40 +01001753 XKB_STATE_EFFECTIVE);
1754
Daniel Stone994679a2012-05-30 16:31:43 +01001755 if (mods_depressed != seat->xkb_state.mods_depressed ||
1756 mods_latched != seat->xkb_state.mods_latched ||
1757 mods_locked != seat->xkb_state.mods_locked ||
1758 group != seat->xkb_state.group)
Daniel Stone7ace3902012-05-30 16:31:40 +01001759 ret = 1;
1760
Daniel Stone994679a2012-05-30 16:31:43 +01001761 seat->xkb_state.mods_depressed = mods_depressed;
1762 seat->xkb_state.mods_latched = mods_latched;
1763 seat->xkb_state.mods_locked = mods_locked;
1764 seat->xkb_state.group = group;
Kristian Høgsbergab909ae2001-01-01 22:24:24 -05001765
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001766 /* And update the modifier_state for bindings. */
1767 mods_lookup = mods_depressed | mods_latched;
1768 seat->modifier_state = 0;
Daniel Stone8db79692012-06-01 12:13:58 +01001769 if (mods_lookup & (1 << seat->xkb_info.ctrl_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001770 seat->modifier_state |= MODIFIER_CTRL;
Daniel Stone8db79692012-06-01 12:13:58 +01001771 if (mods_lookup & (1 << seat->xkb_info.alt_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001772 seat->modifier_state |= MODIFIER_ALT;
Daniel Stone8db79692012-06-01 12:13:58 +01001773 if (mods_lookup & (1 << seat->xkb_info.super_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001774 seat->modifier_state |= MODIFIER_SUPER;
Daniel Stone7ace3902012-05-30 16:31:40 +01001775
Daniel Stone8c8164f2012-05-30 16:31:45 +01001776 /* Finally, notify the compositor that LEDs have changed. */
1777 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001778 seat->xkb_info.num_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001779 leds |= LED_NUM_LOCK;
1780 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001781 seat->xkb_info.caps_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001782 leds |= LED_CAPS_LOCK;
1783 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001784 seat->xkb_info.scroll_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001785 leds |= LED_SCROLL_LOCK;
1786 if (leds != seat->xkb_state.leds && seat->led_update)
Daniel Stonebbf63bf2012-06-04 11:40:48 +01001787 seat->led_update(seat, leds);
Daniel Stone8c8164f2012-05-30 16:31:45 +01001788 seat->xkb_state.leds = leds;
1789
Daniel Stone7ace3902012-05-30 16:31:40 +01001790 return ret;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001791}
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001792
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001793WL_EXPORT void
Daniel Stonec9785ea2012-05-30 16:31:52 +01001794notify_key(struct wl_seat *seat, uint32_t time, uint32_t key,
1795 enum wl_keyboard_key_state state)
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001796{
Daniel Stone37816df2012-05-16 18:45:18 +01001797 struct weston_seat *ws = (struct weston_seat *) seat;
1798 struct weston_compositor *compositor = ws->compositor;
1799 struct weston_surface *focus =
1800 (struct weston_surface *) seat->pointer->focus;
Daniel Stone7ace3902012-05-30 16:31:40 +01001801 struct wl_keyboard_grab *grab = seat->keyboard->grab;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001802 uint32_t serial = wl_display_next_serial(compositor->wl_display);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001803 uint32_t *k, *end;
Daniel Stone7ace3902012-05-30 16:31:40 +01001804 int mods;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001805
Daniel Stonec9785ea2012-05-30 16:31:52 +01001806 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
Scott Moreauff1db4a2012-04-17 19:06:18 -06001807 if (compositor->ping_handler && focus)
1808 compositor->ping_handler(focus, serial);
1809
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001810 weston_compositor_idle_inhibit(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001811 seat->keyboard->grab_key = key;
1812 seat->keyboard->grab_time = time;
Scott Moreauec286eb2012-02-18 05:05:30 -07001813 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001814 weston_compositor_idle_release(compositor);
Scott Moreauec286eb2012-02-18 05:05:30 -07001815 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001816
Daniel Stone7ace3902012-05-30 16:31:40 +01001817 mods = update_modifier_state(ws, key, state);
Daniel Stone37816df2012-05-16 18:45:18 +01001818 end = seat->keyboard->keys.data + seat->keyboard->keys.size;
1819 for (k = seat->keyboard->keys.data; k < end; k++) {
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001820 if (*k == key)
1821 *k = *--end;
1822 }
Daniel Stone37816df2012-05-16 18:45:18 +01001823 seat->keyboard->keys.size = (void *) end - seat->keyboard->keys.data;
Daniel Stonec9785ea2012-05-30 16:31:52 +01001824 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
Daniel Stone37816df2012-05-16 18:45:18 +01001825 k = wl_array_add(&seat->keyboard->keys, sizeof *k);
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001826 *k = key;
1827 }
Ray Strodee96dcb82008-12-20 02:00:49 -05001828
Scott Moreaubefa6532012-06-11 14:59:31 -06001829 if (grab == &seat->keyboard->default_grab) {
Daniel Stone325fc2d2012-05-30 16:31:58 +01001830 weston_compositor_run_key_binding(compositor, ws, time, key,
1831 state);
Scott Moreaubefa6532012-06-11 14:59:31 -06001832 grab = seat->keyboard->grab;
1833 }
Kristian Høgsbergabcef3c2012-03-05 17:47:15 -05001834
Daniel Stone7ace3902012-05-30 16:31:40 +01001835 grab->interface->key(grab, time, key, state);
Daniel Stone351eb612012-05-31 15:27:47 -04001836 if (mods)
1837 grab->interface->modifiers(grab,
1838 wl_display_get_serial(compositor->wl_display),
Daniel Stone994679a2012-05-30 16:31:43 +01001839 ws->xkb_state.mods_depressed,
1840 ws->xkb_state.mods_latched,
1841 ws->xkb_state.mods_locked,
1842 ws->xkb_state.group);
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001843}
1844
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001845WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001846notify_pointer_focus(struct wl_seat *seat, struct weston_output *output,
1847 wl_fixed_t x, wl_fixed_t y)
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001848{
Daniel Stone37816df2012-05-16 18:45:18 +01001849 struct weston_seat *ws = (struct weston_seat *) seat;
1850 struct weston_compositor *compositor = ws->compositor;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001851
1852 if (output) {
Daniel Stone37816df2012-05-16 18:45:18 +01001853 weston_seat_update_drag_surface(seat,
1854 x - seat->pointer->x,
1855 y - seat->pointer->y);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001856
Daniel Stone37816df2012-05-16 18:45:18 +01001857 seat->pointer->x = x;
1858 seat->pointer->y = y;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001859 compositor->focus = 1;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001860 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001861 } else {
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001862 compositor->focus = 0;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001863 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001864 }
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001865}
1866
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001867static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001868destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001869{
Daniel Stone37816df2012-05-16 18:45:18 +01001870 struct weston_seat *ws;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001871
Daniel Stone37816df2012-05-16 18:45:18 +01001872 ws = container_of(listener, struct weston_seat,
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001873 saved_kbd_focus_listener);
1874
Daniel Stone37816df2012-05-16 18:45:18 +01001875 ws->saved_kbd_focus = NULL;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001876}
1877
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001878WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001879notify_keyboard_focus(struct wl_seat *seat, struct wl_array *keys)
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001880{
Daniel Stone37816df2012-05-16 18:45:18 +01001881 struct weston_seat *ws = (struct weston_seat *) seat;
1882 struct weston_compositor *compositor = ws->compositor;
Kristian Høgsbergafee2212012-03-20 17:28:20 -04001883 struct wl_surface *surface;
Kristian Høgsbergd3c02752012-03-04 22:35:47 -05001884 uint32_t *k;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001885
Kristian Høgsberg31dd6b82012-04-09 22:10:00 -04001886 if (keys) {
Daniel Stone37816df2012-05-16 18:45:18 +01001887 wl_array_copy(&seat->keyboard->keys, keys);
1888 ws->modifier_state = 0;
1889 wl_array_for_each(k, &seat->keyboard->keys) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001890 weston_compositor_idle_inhibit(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001891 update_modifier_state(ws, *k, 1);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001892 }
1893
Daniel Stone37816df2012-05-16 18:45:18 +01001894 surface = ws->saved_kbd_focus;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001895
Kristian Høgsbergafee2212012-03-20 17:28:20 -04001896 if (surface) {
Daniel Stone37816df2012-05-16 18:45:18 +01001897 wl_list_remove(&ws->saved_kbd_focus_listener.link);
1898 wl_keyboard_set_focus(ws->seat.keyboard, surface);
Daniel Stone351eb612012-05-31 15:27:47 -04001899
1900 if (seat->keyboard->focus_resource) {
1901 wl_keyboard_send_modifiers(seat->keyboard->focus_resource,
1902 wl_display_next_serial(compositor->wl_display),
Daniel Stone994679a2012-05-30 16:31:43 +01001903 ws->xkb_state.mods_depressed,
1904 ws->xkb_state.mods_latched,
1905 ws->xkb_state.mods_locked,
1906 ws->xkb_state.group);
Daniel Stone351eb612012-05-31 15:27:47 -04001907 }
Daniel Stone37816df2012-05-16 18:45:18 +01001908 ws->saved_kbd_focus = NULL;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001909 }
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001910 } else {
Daniel Stone37816df2012-05-16 18:45:18 +01001911 wl_array_for_each(k, &seat->keyboard->keys)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001912 weston_compositor_idle_release(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001913
Daniel Stone37816df2012-05-16 18:45:18 +01001914 ws->modifier_state = 0;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001915
Daniel Stone37816df2012-05-16 18:45:18 +01001916 surface = ws->seat.keyboard->focus;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001917
Kristian Høgsbergafee2212012-03-20 17:28:20 -04001918 if (surface) {
Daniel Stone37816df2012-05-16 18:45:18 +01001919 ws->saved_kbd_focus = surface;
1920 ws->saved_kbd_focus_listener.notify =
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001921 destroy_device_saved_kbd_focus;
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001922 wl_signal_add(&surface->resource.destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01001923 &ws->saved_kbd_focus_listener);
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001924 }
1925
Daniel Stone37816df2012-05-16 18:45:18 +01001926 wl_keyboard_set_focus(ws->seat.keyboard, NULL);
Kristian Høgsberg035dd9c2012-04-10 00:33:40 -04001927 /* FIXME: We really need keyboard grab cancel here to
1928 * let the grab shut down properly. As it is we leak
1929 * the grab data. */
Daniel Stone37816df2012-05-16 18:45:18 +01001930 wl_keyboard_end_grab(ws->seat.keyboard);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001931 }
1932}
1933
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001934static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001935lose_touch_focus_resource(struct wl_listener *listener, void *data)
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001936{
Daniel Stone37816df2012-05-16 18:45:18 +01001937 struct weston_seat *seat = container_of(listener, struct weston_seat,
1938 touch_focus_resource_listener);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001939
Daniel Stone37816df2012-05-16 18:45:18 +01001940 seat->touch_focus_resource = NULL;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001941}
1942
1943static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001944lose_touch_focus(struct wl_listener *listener, void *data)
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001945{
Daniel Stone37816df2012-05-16 18:45:18 +01001946 struct weston_seat *seat = container_of(listener, struct weston_seat,
1947 touch_focus_listener);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001948
Daniel Stone37816df2012-05-16 18:45:18 +01001949 seat->touch_focus = NULL;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001950}
1951
1952static void
Daniel Stone37816df2012-05-16 18:45:18 +01001953touch_set_focus(struct weston_seat *ws, struct wl_surface *surface)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001954{
Daniel Stone37816df2012-05-16 18:45:18 +01001955 struct wl_seat *seat = &ws->seat;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001956 struct wl_resource *resource;
1957
Daniel Stone37816df2012-05-16 18:45:18 +01001958 if (ws->touch_focus == surface)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001959 return;
1960
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001961 if (surface) {
1962 resource =
Daniel Stone37816df2012-05-16 18:45:18 +01001963 find_resource_for_client(&seat->touch->resource_list,
Casey Dahlin96d8a752012-04-19 22:50:07 -04001964 surface->resource.client);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001965 if (!resource) {
Martin Minarik6d118362012-06-07 18:01:59 +02001966 weston_log("couldn't find resource\n");
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001967 return;
1968 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001969
Daniel Stone37816df2012-05-16 18:45:18 +01001970 ws->touch_focus_resource_listener.notify =
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001971 lose_touch_focus_resource;
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001972 wl_signal_add(&resource->destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01001973 &ws->touch_focus_resource_listener);
1974 ws->touch_focus_listener.notify = lose_touch_focus;
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001975 wl_signal_add(&surface->resource.destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01001976 &ws->touch_focus_listener);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001977
Daniel Stone37816df2012-05-16 18:45:18 +01001978 seat->touch->focus = surface;
1979 seat->touch->focus_resource = resource;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001980 } else {
Daniel Stone37816df2012-05-16 18:45:18 +01001981 if (seat->touch->focus)
1982 wl_list_remove(&ws->touch_focus_listener.link);
1983 if (seat->touch->focus_resource)
1984 wl_list_remove(&ws->touch_focus_resource_listener.link);
1985 seat->touch->focus = NULL;
1986 seat->touch->focus_resource = NULL;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001987 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001988}
1989
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001990/**
1991 * notify_touch - emulates button touches and notifies surfaces accordingly.
1992 *
1993 * It assumes always the correct cycle sequence until it gets here: touch_down
1994 * → touch_update → ... → touch_update → touch_end. The driver is responsible
1995 * for sending along such order.
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001996 *
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001997 */
1998WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001999notify_touch(struct wl_seat *seat, uint32_t time, int touch_id,
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002000 wl_fixed_t x, wl_fixed_t y, int touch_type)
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002001{
Daniel Stone37816df2012-05-16 18:45:18 +01002002 struct weston_seat *ws = (struct weston_seat *) seat;
2003 struct weston_compositor *ec = ws->compositor;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002004 struct weston_surface *es;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002005 wl_fixed_t sx, sy;
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04002006 uint32_t serial = 0;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002007
2008 switch (touch_type) {
Daniel Stone37816df2012-05-16 18:45:18 +01002009 case WL_TOUCH_DOWN:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002010 weston_compositor_idle_inhibit(ec);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002011
Daniel Stone37816df2012-05-16 18:45:18 +01002012 ws->num_tp++;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002013
2014 /* the first finger down picks the surface, and all further go
2015 * to that surface for the remainder of the touch session i.e.
2016 * until all touch points are up again. */
Daniel Stone37816df2012-05-16 18:45:18 +01002017 if (ws->num_tp == 1) {
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002018 es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
Daniel Stone37816df2012-05-16 18:45:18 +01002019 touch_set_focus(ws, &es->surface);
2020 } else if (ws->touch_focus) {
2021 es = (struct weston_surface *) ws->touch_focus;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002022 weston_surface_from_global_fixed(es, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002023 }
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002024
Daniel Stone37816df2012-05-16 18:45:18 +01002025 if (ws->touch_focus_resource && ws->touch_focus)
2026 wl_touch_send_down(ws->touch_focus_resource,
2027 serial, time,
2028 &ws->touch_focus->resource,
2029 touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002030 break;
Daniel Stone37816df2012-05-16 18:45:18 +01002031 case WL_TOUCH_MOTION:
2032 es = (struct weston_surface *) ws->touch_focus;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002033 if (!es)
2034 break;
2035
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002036 weston_surface_from_global_fixed(es, x, y, &sx, &sy);
Daniel Stone37816df2012-05-16 18:45:18 +01002037 if (ws->touch_focus_resource)
2038 wl_touch_send_motion(ws->touch_focus_resource,
2039 time, touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002040 break;
Daniel Stone37816df2012-05-16 18:45:18 +01002041 case WL_TOUCH_UP:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002042 weston_compositor_idle_release(ec);
Daniel Stone37816df2012-05-16 18:45:18 +01002043 ws->num_tp--;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002044
Daniel Stone37816df2012-05-16 18:45:18 +01002045 if (ws->touch_focus_resource)
2046 wl_touch_send_up(ws->touch_focus_resource,
2047 serial, time, touch_id);
2048 if (ws->num_tp == 0)
2049 touch_set_focus(ws, NULL);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002050 break;
2051 }
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002052}
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05002053
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04002054static void
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002055pointer_handle_sprite_destroy(struct wl_listener *listener, void *data)
2056{
2057 struct weston_seat *seat = container_of(listener, struct weston_seat,
2058 sprite_destroy_listener);
2059
2060 seat->sprite = NULL;
2061}
2062
2063static void
2064pointer_cursor_surface_configure(struct weston_surface *es,
2065 int32_t dx, int32_t dy)
2066{
2067 struct weston_seat *seat = es->private;
2068 int x, y;
2069
2070 assert(es == seat->sprite);
2071
2072 seat->hotspot_x -= dx;
2073 seat->hotspot_y -= dy;
2074
2075 x = wl_fixed_to_int(seat->seat.pointer->x) - seat->hotspot_x;
2076 y = wl_fixed_to_int(seat->seat.pointer->y) - seat->hotspot_y;
2077
2078 weston_surface_configure(seat->sprite, x, y,
2079 es->buffer->width, es->buffer->height);
2080
2081 if (!weston_surface_is_mapped(es)) {
2082 wl_list_insert(&es->compositor->cursor_layer.surface_list,
2083 &es->layer_link);
2084 weston_surface_assign_output(es);
2085 empty_region(&es->input);
2086 }
2087}
2088
2089static void
2090pointer_unmap_sprite(struct weston_seat *seat)
2091{
2092 if (weston_surface_is_mapped(seat->sprite))
2093 weston_surface_unmap(seat->sprite);
2094
2095 wl_list_remove(&seat->sprite_destroy_listener.link);
2096 seat->sprite->configure = NULL;
2097 seat->sprite->private = NULL;
2098 seat->sprite = NULL;
2099}
2100
2101static void
2102pointer_set_cursor(struct wl_client *client, struct wl_resource *resource,
2103 uint32_t serial, struct wl_resource *surface_resource,
2104 int32_t x, int32_t y)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002105{
Daniel Stone37816df2012-05-16 18:45:18 +01002106 struct weston_seat *seat = resource->data;
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002107 struct weston_surface *surface = NULL;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002108
Daniel Stone37816df2012-05-16 18:45:18 +01002109 if (serial < seat->seat.pointer->focus_serial)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002110 return;
Daniel Stone37816df2012-05-16 18:45:18 +01002111 if (seat->seat.pointer->focus == NULL)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002112 return;
Daniel Stone37816df2012-05-16 18:45:18 +01002113 if (seat->seat.pointer->focus->resource.client != client)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002114 return;
2115
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002116 if (surface_resource)
2117 surface = container_of(surface_resource->data,
2118 struct weston_surface, surface);
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04002119
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002120 if (surface && surface != seat->sprite && surface->configure) {
2121 wl_resource_post_error(&surface->surface.resource,
2122 WL_DISPLAY_ERROR_INVALID_OBJECT,
2123 "surface->configure already set");
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002124 return;
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02002125 }
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05002126
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002127 if (seat->sprite)
2128 pointer_unmap_sprite(seat);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03002129
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002130 if (!surface)
2131 return;
2132
2133 wl_signal_add(&surface->surface.resource.destroy_signal,
2134 &seat->sprite_destroy_listener);
2135
2136 surface->configure = pointer_cursor_surface_configure;
2137 surface->private = seat;
2138 empty_region(&surface->input);
2139
2140 seat->sprite = surface;
Daniel Stone37816df2012-05-16 18:45:18 +01002141 seat->hotspot_x = x;
2142 seat->hotspot_y = y;
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05002143
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002144 weston_surface_set_position(surface,
2145 wl_fixed_to_int(seat->seat.pointer->x) - x,
2146 wl_fixed_to_int(seat->seat.pointer->y) - y);
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002147}
2148
Daniel Stone37816df2012-05-16 18:45:18 +01002149static const struct wl_pointer_interface pointer_interface = {
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002150 pointer_set_cursor
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002151};
2152
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002153static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002154handle_drag_surface_destroy(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002155{
Daniel Stone37816df2012-05-16 18:45:18 +01002156 struct weston_seat *seat;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002157
Daniel Stone37816df2012-05-16 18:45:18 +01002158 seat = container_of(listener, struct weston_seat,
2159 drag_surface_destroy_listener);
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002160
Daniel Stone37816df2012-05-16 18:45:18 +01002161 seat->drag_surface = NULL;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002162}
2163
Casey Dahlin9074db52012-04-19 22:50:09 -04002164static void unbind_resource(struct wl_resource *resource)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04002165{
2166 wl_list_remove(&resource->link);
2167 free(resource);
2168}
2169
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002170static void
Daniel Stone37816df2012-05-16 18:45:18 +01002171seat_get_pointer(struct wl_client *client, struct wl_resource *resource,
2172 uint32_t id)
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002173{
Daniel Stone37816df2012-05-16 18:45:18 +01002174 struct weston_seat *seat = resource->data;
2175 struct wl_resource *cr;
Kristian Høgsberg8e6d7122011-08-29 16:04:39 -04002176
Daniel Stone37816df2012-05-16 18:45:18 +01002177 if (!seat->seat.pointer)
2178 return;
2179
2180 cr = wl_client_add_object(client, &wl_pointer_interface,
2181 &pointer_interface, id, seat);
2182 wl_list_insert(&seat->seat.pointer->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002183 cr->destroy = unbind_resource;
Daniel Stone17b13bd2012-05-30 16:31:39 +01002184
2185 if (seat->seat.pointer->focus &&
2186 seat->seat.pointer->focus->resource.client == client) {
2187 struct weston_surface *surface;
2188 wl_fixed_t sx, sy;
2189
2190 surface = (struct weston_surface *) seat->seat.pointer->focus;
2191 weston_surface_from_global_fixed(surface,
2192 seat->seat.pointer->x,
2193 seat->seat.pointer->y,
2194 &sx,
2195 &sy);
2196 wl_pointer_set_focus(seat->seat.pointer,
2197 seat->seat.pointer->focus,
2198 sx,
2199 sy);
2200 }
Daniel Stone37816df2012-05-16 18:45:18 +01002201}
2202
2203static void
2204seat_get_keyboard(struct wl_client *client, struct wl_resource *resource,
2205 uint32_t id)
2206{
2207 struct weston_seat *seat = resource->data;
2208 struct wl_resource *cr;
2209
2210 if (!seat->seat.keyboard)
2211 return;
2212
2213 cr = wl_client_add_object(client, &wl_keyboard_interface, NULL, id,
2214 seat);
2215 wl_list_insert(&seat->seat.keyboard->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002216 cr->destroy = unbind_resource;
Daniel Stone17b13bd2012-05-30 16:31:39 +01002217
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002218 wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
2219 seat->xkb_info.keymap_fd,
2220 seat->xkb_info.keymap_size);
2221
Daniel Stone17b13bd2012-05-30 16:31:39 +01002222 if (seat->seat.keyboard->focus &&
2223 seat->seat.keyboard->focus->resource.client == client) {
2224 wl_keyboard_set_focus(seat->seat.keyboard,
2225 seat->seat.keyboard->focus);
2226 }
Daniel Stone37816df2012-05-16 18:45:18 +01002227}
2228
2229static void
2230seat_get_touch(struct wl_client *client, struct wl_resource *resource,
2231 uint32_t id)
2232{
2233 struct weston_seat *seat = resource->data;
2234 struct wl_resource *cr;
2235
2236 if (!seat->seat.touch)
2237 return;
2238
2239 cr = wl_client_add_object(client, &wl_touch_interface, NULL, id, seat);
2240 wl_list_insert(&seat->seat.touch->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002241 cr->destroy = unbind_resource;
Daniel Stone37816df2012-05-16 18:45:18 +01002242}
2243
2244static const struct wl_seat_interface seat_interface = {
2245 seat_get_pointer,
2246 seat_get_keyboard,
2247 seat_get_touch,
2248};
2249
2250static void
2251bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id)
2252{
2253 struct wl_seat *seat = data;
2254 struct wl_resource *resource;
2255 enum wl_seat_capability caps = 0;
2256
2257 resource = wl_client_add_object(client, &wl_seat_interface,
2258 &seat_interface, id, data);
2259 wl_list_insert(&seat->base_resource_list, &resource->link);
Casey Dahlin9074db52012-04-19 22:50:09 -04002260 resource->destroy = unbind_resource;
Daniel Stone37816df2012-05-16 18:45:18 +01002261
2262 if (seat->pointer)
2263 caps |= WL_SEAT_CAPABILITY_POINTER;
2264 if (seat->keyboard)
2265 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
2266 if (seat->touch)
2267 caps |= WL_SEAT_CAPABILITY_TOUCH;
2268
2269 wl_seat_send_capabilities(resource, caps);
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002270}
2271
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002272static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002273device_handle_new_drag_icon(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002274{
Daniel Stone37816df2012-05-16 18:45:18 +01002275 struct weston_seat *seat;
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002276
Daniel Stone37816df2012-05-16 18:45:18 +01002277 seat = container_of(listener, struct weston_seat,
2278 new_drag_icon_listener);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002279
Daniel Stone37816df2012-05-16 18:45:18 +01002280 weston_seat_update_drag_surface(&seat->seat, 0, 0);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002281}
2282
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002283static void weston_compositor_xkb_init(struct weston_compositor *ec,
2284 struct xkb_rule_names *names)
Daniel Stone994679a2012-05-30 16:31:43 +01002285{
Daniel Stonee379da92012-05-30 16:32:04 +01002286 if (ec->xkb_context == NULL) {
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002287 ec->xkb_context = xkb_context_new(0);
2288 if (ec->xkb_context == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002289 weston_log("failed to create XKB context\n");
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002290 exit(1);
2291 }
Daniel Stone994679a2012-05-30 16:31:43 +01002292 }
2293
2294 if (names)
Daniel Stonee379da92012-05-30 16:32:04 +01002295 ec->xkb_names = *names;
2296 if (!ec->xkb_names.rules)
2297 ec->xkb_names.rules = strdup("evdev");
2298 if (!ec->xkb_names.model)
2299 ec->xkb_names.model = strdup("pc105");
2300 if (!ec->xkb_names.layout)
2301 ec->xkb_names.layout = strdup("us");
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002302}
2303
Daniel Stonee379da92012-05-30 16:32:04 +01002304static void xkb_info_destroy(struct weston_xkb_info *xkb_info)
2305{
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002306 if (xkb_info->keymap)
2307 xkb_map_unref(xkb_info->keymap);
2308
2309 if (xkb_info->keymap_area)
2310 munmap(xkb_info->keymap_area, xkb_info->keymap_size);
2311 if (xkb_info->keymap_fd >= 0)
2312 close(xkb_info->keymap_fd);
Daniel Stonee379da92012-05-30 16:32:04 +01002313}
2314
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002315static void weston_compositor_xkb_destroy(struct weston_compositor *ec)
2316{
Daniel Stonee379da92012-05-30 16:32:04 +01002317 free((char *) ec->xkb_names.rules);
2318 free((char *) ec->xkb_names.model);
2319 free((char *) ec->xkb_names.layout);
2320 free((char *) ec->xkb_names.variant);
2321 free((char *) ec->xkb_names.options);
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002322
Daniel Stonee379da92012-05-30 16:32:04 +01002323 xkb_info_destroy(&ec->xkb_info);
2324 xkb_context_unref(ec->xkb_context);
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002325}
2326
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002327static void
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002328weston_xkb_info_new_keymap(struct weston_xkb_info *xkb_info)
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002329{
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002330 char *keymap_str;
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002331
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002332 xkb_info->ctrl_mod = xkb_map_mod_get_index(xkb_info->keymap,
2333 XKB_MOD_NAME_CTRL);
2334 xkb_info->alt_mod = xkb_map_mod_get_index(xkb_info->keymap,
2335 XKB_MOD_NAME_ALT);
2336 xkb_info->super_mod = xkb_map_mod_get_index(xkb_info->keymap,
2337 XKB_MOD_NAME_LOGO);
2338
2339 xkb_info->num_led = xkb_map_led_get_index(xkb_info->keymap,
2340 XKB_LED_NAME_NUM);
2341 xkb_info->caps_led = xkb_map_led_get_index(xkb_info->keymap,
2342 XKB_LED_NAME_CAPS);
2343 xkb_info->scroll_led = xkb_map_led_get_index(xkb_info->keymap,
2344 XKB_LED_NAME_SCROLL);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002345
2346 keymap_str = xkb_map_get_as_string(xkb_info->keymap);
2347 if (keymap_str == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002348 weston_log("failed to get string version of keymap\n");
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002349 exit(EXIT_FAILURE);
2350 }
2351 xkb_info->keymap_size = strlen(keymap_str) + 1;
2352
Pekka Paalanen1da1b8f2012-06-06 16:59:43 +03002353 xkb_info->keymap_fd = os_create_anonymous_file(xkb_info->keymap_size);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002354 if (xkb_info->keymap_fd < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02002355 weston_log("creating a keymap file for %lu bytes failed: %m\n",
Pekka Paalanen1da1b8f2012-06-06 16:59:43 +03002356 (unsigned long) xkb_info->keymap_size);
2357 goto err_keymap_str;
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002358 }
2359
2360 xkb_info->keymap_area = mmap(NULL, xkb_info->keymap_size,
2361 PROT_READ | PROT_WRITE,
2362 MAP_SHARED, xkb_info->keymap_fd, 0);
2363 if (xkb_info->keymap_area == MAP_FAILED) {
Martin Minarik6d118362012-06-07 18:01:59 +02002364 weston_log("failed to mmap() %lu bytes\n",
Pekka Paalanen1da1b8f2012-06-06 16:59:43 +03002365 (unsigned long) xkb_info->keymap_size);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002366 goto err_dev_zero;
2367 }
2368 strcpy(xkb_info->keymap_area, keymap_str);
2369 free(keymap_str);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002370
2371 return;
2372
2373err_dev_zero:
2374 close(xkb_info->keymap_fd);
2375 xkb_info->keymap_fd = -1;
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002376err_keymap_str:
2377 free(keymap_str);
2378 exit(EXIT_FAILURE);
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002379}
2380
2381static void
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002382weston_compositor_build_global_keymap(struct weston_compositor *ec)
2383{
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002384 if (ec->xkb_info.keymap != NULL)
2385 return;
2386
Daniel Stonee379da92012-05-30 16:32:04 +01002387 ec->xkb_info.keymap = xkb_map_new_from_names(ec->xkb_context,
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002388 &ec->xkb_names,
2389 0);
Daniel Stone994679a2012-05-30 16:31:43 +01002390 if (ec->xkb_info.keymap == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002391 weston_log("failed to compile global XKB keymap\n");
2392 weston_log(" tried rules %s, model %s, layout %s, variant %s, "
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002393 "options %s",
2394 ec->xkb_names.rules, ec->xkb_names.model,
2395 ec->xkb_names.layout, ec->xkb_names.variant,
2396 ec->xkb_names.options);
2397 exit(1);
Daniel Stone994679a2012-05-30 16:31:43 +01002398 }
2399
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002400 weston_xkb_info_new_keymap(&ec->xkb_info);
Daniel Stone994679a2012-05-30 16:31:43 +01002401}
2402
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002403WL_EXPORT void
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002404weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap)
Daniel Stone994679a2012-05-30 16:31:43 +01002405{
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002406 if (seat->has_keyboard)
2407 return;
Daniel Stone994679a2012-05-30 16:31:43 +01002408
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002409 if (keymap != NULL) {
2410 seat->xkb_info.keymap = xkb_map_ref(keymap);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002411 weston_xkb_info_new_keymap(&seat->xkb_info);
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002412 }
2413 else {
2414 weston_compositor_build_global_keymap(seat->compositor);
2415 seat->xkb_info = seat->compositor->xkb_info;
2416 seat->xkb_info.keymap = xkb_map_ref(seat->xkb_info.keymap);
2417 }
Daniel Stoned65b9092012-05-30 16:32:05 +01002418
2419 seat->xkb_state.state = xkb_state_new(seat->xkb_info.keymap);
2420 if (seat->xkb_state.state == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002421 weston_log("failed to initialise XKB state\n");
Daniel Stoned65b9092012-05-30 16:32:05 +01002422 exit(1);
2423 }
2424
2425 seat->xkb_state.mods_depressed = 0;
2426 seat->xkb_state.mods_latched = 0;
2427 seat->xkb_state.mods_locked = 0;
2428 seat->xkb_state.group = 0;
2429
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002430 wl_keyboard_init(&seat->keyboard);
2431 wl_seat_set_keyboard(&seat->seat, &seat->keyboard);
2432
2433 seat->has_keyboard = 1;
Daniel Stone994679a2012-05-30 16:31:43 +01002434}
2435
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002436WL_EXPORT void
Daniel Stone74419a22012-05-30 16:32:02 +01002437weston_seat_init_pointer(struct weston_seat *seat)
2438{
2439 if (seat->has_pointer)
2440 return;
2441
2442 wl_pointer_init(&seat->pointer);
2443 wl_seat_set_pointer(&seat->seat, &seat->pointer);
2444
2445 seat->has_pointer = 1;
2446}
2447
2448WL_EXPORT void
Daniel Stone74419a22012-05-30 16:32:02 +01002449weston_seat_init_touch(struct weston_seat *seat)
2450{
2451 if (seat->has_touch)
2452 return;
2453
2454 wl_touch_init(&seat->touch);
2455 wl_seat_set_touch(&seat->seat, &seat->touch);
2456
2457 seat->has_touch = 1;
2458}
2459
2460WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01002461weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05002462{
Daniel Stone37816df2012-05-16 18:45:18 +01002463 wl_seat_init(&seat->seat);
Daniel Stone74419a22012-05-30 16:32:02 +01002464 seat->has_pointer = 0;
2465 seat->has_keyboard = 0;
2466 seat->has_touch = 0;
Kristian Høgsberg02ef1c12010-12-06 21:35:19 -05002467
Daniel Stone37816df2012-05-16 18:45:18 +01002468 wl_display_add_global(ec->wl_display, &wl_seat_interface, seat,
2469 bind_seat);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04002470
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002471 seat->sprite = NULL;
2472 seat->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
Kristian Høgsberg8244b442011-06-23 15:44:14 -04002473
Daniel Stone37816df2012-05-16 18:45:18 +01002474 seat->compositor = ec;
2475 seat->hotspot_x = 16;
2476 seat->hotspot_y = 16;
2477 seat->modifier_state = 0;
2478 seat->num_tp = 0;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05002479
Daniel Stone37816df2012-05-16 18:45:18 +01002480 seat->drag_surface_destroy_listener.notify =
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002481 handle_drag_surface_destroy;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002482
Daniel Stone37816df2012-05-16 18:45:18 +01002483 wl_list_insert(ec->seat_list.prev, &seat->link);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002484
Daniel Stone37816df2012-05-16 18:45:18 +01002485 seat->new_drag_icon_listener.notify = device_handle_new_drag_icon;
2486 wl_signal_add(&seat->seat.drag_icon_signal,
2487 &seat->new_drag_icon_listener);
Kristian Høgsberga7ceaff2012-06-03 10:20:13 -04002488
2489 clipboard_create(seat);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05002490}
2491
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002492WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01002493weston_seat_release(struct weston_seat *seat)
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002494{
Daniel Stone37816df2012-05-16 18:45:18 +01002495 wl_list_remove(&seat->link);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002496 /* The global object is destroyed at wl_display_destroy() time. */
2497
Daniel Stone37816df2012-05-16 18:45:18 +01002498 if (seat->sprite)
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002499 pointer_unmap_sprite(seat);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002500
Daniel Stone74419a22012-05-30 16:32:02 +01002501 if (seat->xkb_state.state != NULL)
2502 xkb_state_unref(seat->xkb_state.state);
Daniel Stoned65b9092012-05-30 16:32:05 +01002503 xkb_info_destroy(&seat->xkb_info);
Daniel Stone994679a2012-05-30 16:31:43 +01002504
Daniel Stone37816df2012-05-16 18:45:18 +01002505 wl_seat_release(&seat->seat);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002506}
2507
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002508static void
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002509drag_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
2510{
2511 weston_surface_configure(es,
2512 es->geometry.x + sx, es->geometry.y + sy,
2513 es->buffer->width, es->buffer->height);
2514}
2515
2516static int
Daniel Stone37816df2012-05-16 18:45:18 +01002517device_setup_new_drag_surface(struct weston_seat *ws,
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002518 struct weston_surface *surface)
2519{
Daniel Stone37816df2012-05-16 18:45:18 +01002520 struct wl_seat *seat = &ws->seat;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002521
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002522 if (surface->configure) {
2523 wl_resource_post_error(&surface->surface.resource,
2524 WL_DISPLAY_ERROR_INVALID_OBJECT,
2525 "surface->configure already set");
2526 return 0;
2527 }
2528
Daniel Stone37816df2012-05-16 18:45:18 +01002529 ws->drag_surface = surface;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002530
Daniel Stone37816df2012-05-16 18:45:18 +01002531 weston_surface_set_position(ws->drag_surface,
2532 wl_fixed_to_double(seat->pointer->x),
2533 wl_fixed_to_double(seat->pointer->y));
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002534
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002535 surface->configure = drag_surface_configure;
2536
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002537 wl_signal_add(&surface->surface.resource.destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01002538 &ws->drag_surface_destroy_listener);
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002539
2540 return 1;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002541}
2542
2543static void
Daniel Stone37816df2012-05-16 18:45:18 +01002544device_release_drag_surface(struct weston_seat *seat)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002545{
Daniel Stone37816df2012-05-16 18:45:18 +01002546 seat->drag_surface->configure = NULL;
2547 undef_region(&seat->drag_surface->input);
2548 wl_list_remove(&seat->drag_surface_destroy_listener.link);
2549 seat->drag_surface = NULL;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002550}
2551
2552static void
Daniel Stone37816df2012-05-16 18:45:18 +01002553device_map_drag_surface(struct weston_seat *seat)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002554{
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002555 struct wl_list *list;
2556
Daniel Stone37816df2012-05-16 18:45:18 +01002557 if (weston_surface_is_mapped(seat->drag_surface) ||
2558 !seat->drag_surface->buffer)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002559 return;
2560
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002561 if (seat->sprite && weston_surface_is_mapped(seat->sprite))
2562 list = &seat->sprite->layer_link;
2563 else
2564 list = &seat->compositor->cursor_layer.surface_list;
2565
2566 wl_list_insert(list, &seat->drag_surface->layer_link);
Daniel Stone37816df2012-05-16 18:45:18 +01002567 weston_surface_assign_output(seat->drag_surface);
2568 empty_region(&seat->drag_surface->input);
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002569}
2570
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002571static void
Daniel Stone37816df2012-05-16 18:45:18 +01002572weston_seat_update_drag_surface(struct wl_seat *seat,
2573 int dx, int dy)
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002574{
2575 int surface_changed = 0;
Daniel Stone37816df2012-05-16 18:45:18 +01002576 struct weston_seat *ws = (struct weston_seat *) seat;
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002577
Daniel Stone37816df2012-05-16 18:45:18 +01002578 if (!ws->drag_surface && !seat->drag_surface)
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002579 return;
2580
Daniel Stone37816df2012-05-16 18:45:18 +01002581 if (ws->drag_surface && seat->drag_surface &&
2582 (&ws->drag_surface->surface.resource !=
2583 &seat->drag_surface->resource))
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002584 /* between calls to this funcion we got a new drag_surface */
2585 surface_changed = 1;
2586
Daniel Stone37816df2012-05-16 18:45:18 +01002587 if (!seat->drag_surface || surface_changed) {
2588 device_release_drag_surface(ws);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002589 if (!surface_changed)
2590 return;
2591 }
2592
Daniel Stone37816df2012-05-16 18:45:18 +01002593 if (!ws->drag_surface || surface_changed) {
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002594 struct weston_surface *surface = (struct weston_surface *)
Daniel Stone37816df2012-05-16 18:45:18 +01002595 seat->drag_surface;
2596 if (!device_setup_new_drag_surface(ws, surface))
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002597 return;
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002598 }
2599
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002600 /* the client may not have attached a buffer to the drag surface
2601 * when we setup it up, so check if map is needed on every update */
Daniel Stone37816df2012-05-16 18:45:18 +01002602 device_map_drag_surface(ws);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002603
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +02002604 /* the client may have attached a buffer with a different size to
2605 * the drag surface, causing the input region to be reset */
Daniel Stone37816df2012-05-16 18:45:18 +01002606 if (region_is_undefined(&ws->drag_surface->input))
2607 empty_region(&ws->drag_surface->input);
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +02002608
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002609 if (!dx && !dy)
2610 return;
2611
Daniel Stone37816df2012-05-16 18:45:18 +01002612 weston_surface_set_position(ws->drag_surface,
2613 ws->drag_surface->geometry.x + wl_fixed_to_double(dx),
2614 ws->drag_surface->geometry.y + wl_fixed_to_double(dy));
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002615}
2616
2617WL_EXPORT void
2618weston_compositor_update_drag_surfaces(struct weston_compositor *compositor)
2619{
Daniel Stone4dab5db2012-05-30 16:31:53 +01002620 struct weston_seat *seat;
2621
2622 wl_list_for_each(seat, &compositor->seat_list, link)
2623 weston_seat_update_drag_surface(&seat->seat, 0, 0);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002624}
2625
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002626static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002627bind_output(struct wl_client *client,
2628 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05002629{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002630 struct weston_output *output = data;
2631 struct weston_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04002632 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002633
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04002634 resource = wl_client_add_object(client,
2635 &wl_output_interface, NULL, id, data);
2636
Casey Dahlin9074db52012-04-19 22:50:09 -04002637 wl_list_insert(&output->resource_list, &resource->link);
2638 resource->destroy = unbind_resource;
2639
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05002640 wl_output_send_geometry(resource,
2641 output->x,
2642 output->y,
2643 output->mm_width,
2644 output->mm_height,
2645 output->subpixel,
2646 output->make, output->model);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002647
2648 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05002649 wl_output_send_mode(resource,
2650 mode->flags,
2651 mode->width,
2652 mode->height,
2653 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002654 }
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002655}
2656
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002657static const char vertex_shader[] =
2658 "uniform mat4 proj;\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05002659 "attribute vec2 position;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002660 "attribute vec2 texcoord;\n"
2661 "varying vec2 v_texcoord;\n"
2662 "void main()\n"
2663 "{\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05002664 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002665 " v_texcoord = texcoord;\n"
2666 "}\n";
2667
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002668static const char texture_fragment_shader[] =
Kristian Høgsbergdfce71d2010-12-07 20:19:10 -05002669 "precision mediump float;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002670 "varying vec2 v_texcoord;\n"
2671 "uniform sampler2D tex;\n"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002672 "uniform float alpha;\n"
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02002673 "uniform float texwidth;\n"
Kristian Høgsberg0b0c2bb2012-05-15 23:16:53 -04002674 "uniform vec4 opaque;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002675 "void main()\n"
2676 "{\n"
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02002677 " if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n"
2678 " v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n"
2679 " discard;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002680 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
Kristian Høgsberg0b0c2bb2012-05-15 23:16:53 -04002681 " if (opaque.x <= v_texcoord.x && v_texcoord.x < opaque.y &&\n"
2682 " opaque.z <= v_texcoord.y && v_texcoord.y < opaque.w)\n"
2683 " gl_FragColor.a = 1.0;\n"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002684 " gl_FragColor = alpha * gl_FragColor;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002685 "}\n";
2686
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002687static const char solid_fragment_shader[] =
2688 "precision mediump float;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002689 "uniform vec4 color;\n"
Kristian Høgsbergdbae80e2012-03-29 11:34:39 -04002690 "uniform float alpha;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002691 "void main()\n"
2692 "{\n"
Kristian Høgsbergdbae80e2012-03-29 11:34:39 -04002693 " gl_FragColor = alpha * color\n;"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002694 "}\n";
2695
Kristian Høgsberga9468212010-06-14 21:03:11 -04002696static int
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002697compile_shader(GLenum type, const char *source)
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002698{
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002699 GLuint s;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002700 char msg[512];
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002701 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002702
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002703 s = glCreateShader(type);
2704 glShaderSource(s, 1, &source, NULL);
2705 glCompileShader(s);
2706 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002707 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002708 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
Martin Minarik6d118362012-06-07 18:01:59 +02002709 weston_log("shader info: %s\n", msg);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002710 return GL_NONE;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002711 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002712
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002713 return s;
2714}
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002715
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002716static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002717weston_shader_init(struct weston_shader *shader,
2718 const char *vertex_source, const char *fragment_source)
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002719{
2720 char msg[512];
2721 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002722
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002723 shader->vertex_shader =
2724 compile_shader(GL_VERTEX_SHADER, vertex_source);
2725 shader->fragment_shader =
2726 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
2727
2728 shader->program = glCreateProgram();
2729 glAttachShader(shader->program, shader->vertex_shader);
2730 glAttachShader(shader->program, shader->fragment_shader);
2731 glBindAttribLocation(shader->program, 0, "position");
2732 glBindAttribLocation(shader->program, 1, "texcoord");
2733
2734 glLinkProgram(shader->program);
2735 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002736 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002737 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
Martin Minarik6d118362012-06-07 18:01:59 +02002738 weston_log("link info: %s\n", msg);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002739 return -1;
2740 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002741
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002742 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
2743 shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002744 shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
Pekka Paalanenf55f5442012-02-02 16:49:05 +02002745 shader->color_uniform = glGetUniformLocation(shader->program, "color");
Scott Moreau9fb98242012-05-22 10:18:50 -06002746 shader->texwidth_uniform = glGetUniformLocation(shader->program, "texwidth");
2747 shader->opaque_uniform = glGetUniformLocation(shader->program, "opaque");
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002748
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002749 return 0;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002750}
2751
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002752WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002753weston_output_destroy(struct weston_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002754{
Benjamin Franzkeb6879402012-04-10 18:28:54 +02002755 struct weston_compositor *c = output->compositor;
2756
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04002757 pixman_region32_fini(&output->region);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04002758 pixman_region32_fini(&output->previous_damage);
Casey Dahlin9074db52012-04-19 22:50:09 -04002759 output->compositor->output_id_pool &= ~(1 << output->id);
Benjamin Franzkeb6879402012-04-10 18:28:54 +02002760
2761 wl_display_remove_global(c->wl_display, output->global);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002762}
2763
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002764WL_EXPORT void
Scott Moreauccbf29d2012-02-22 14:21:41 -07002765weston_output_update_matrix(struct weston_output *output)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002766{
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01002767 int flip;
Scott Moreau850ca422012-05-21 15:21:25 -06002768 float magnification;
Scott Moreauccbf29d2012-02-22 14:21:41 -07002769 struct weston_matrix camera;
2770 struct weston_matrix modelview;
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05002771
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002772 weston_matrix_init(&output->matrix);
2773 weston_matrix_translate(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002774 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
2775 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01002776
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002777 flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002778 weston_matrix_scale(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002779 2.0 / (output->current->width + output->border.left + output->border.right),
2780 flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
Scott Moreau850ca422012-05-21 15:21:25 -06002781
Scott Moreauccbf29d2012-02-22 14:21:41 -07002782 if (output->zoom.active) {
Scott Moreaue6603982012-06-11 13:07:51 -06002783 magnification = 1 / (1 - output->zoom.spring_z.current);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002784 weston_matrix_init(&camera);
2785 weston_matrix_init(&modelview);
Scott Moreau8dacaab2012-06-17 18:10:58 -06002786 weston_output_update_zoom(output, output->zoom.type);
Scott Moreaue6603982012-06-11 13:07:51 -06002787 weston_matrix_translate(&camera, output->zoom.trans_x,
2788 flip * output->zoom.trans_y, 0);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002789 weston_matrix_invert(&modelview, &camera);
Scott Moreau850ca422012-05-21 15:21:25 -06002790 weston_matrix_scale(&modelview, magnification, magnification, 1.0);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002791 weston_matrix_multiply(&output->matrix, &modelview);
2792 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002793
Scott Moreauccbf29d2012-02-22 14:21:41 -07002794 output->dirty = 0;
2795}
2796
2797WL_EXPORT void
2798weston_output_move(struct weston_output *output, int x, int y)
2799{
2800 output->x = x;
2801 output->y = y;
2802
2803 pixman_region32_init(&output->previous_damage);
2804 pixman_region32_init_rect(&output->region, x, y,
2805 output->current->width,
2806 output->current->height);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002807}
2808
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002809WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002810weston_output_init(struct weston_output *output, struct weston_compositor *c,
2811 int x, int y, int width, int height, uint32_t flags)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002812{
2813 output->compositor = c;
2814 output->x = x;
2815 output->y = y;
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002816 output->border.top = 0;
2817 output->border.bottom = 0;
2818 output->border.left = 0;
2819 output->border.right = 0;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002820 output->mm_width = width;
2821 output->mm_height = height;
Scott Moreauccbf29d2012-02-22 14:21:41 -07002822 output->dirty = 1;
Scott Moreau062be7e2012-04-20 13:37:33 -06002823 wl_list_init(&output->read_pixels_list);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002824
Scott Moreau429490d2012-06-17 18:10:59 -06002825 weston_output_init_zoom(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002826
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002827 output->flags = flags;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002828 weston_output_move(output, x, y);
Benjamin Franzke78db8482012-04-10 18:35:33 +02002829 weston_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002830
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -04002831 wl_signal_init(&output->frame_signal);
Scott Moreau9d1b1122012-06-08 19:40:53 -06002832 wl_list_init(&output->animation_list);
Casey Dahlin9074db52012-04-19 22:50:09 -04002833 wl_list_init(&output->resource_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02002834
Casey Dahlin58ba1372012-04-19 22:50:08 -04002835 output->id = ffs(~output->compositor->output_id_pool) - 1;
2836 output->compositor->output_id_pool |= 1 << output->id;
2837
Benjamin Franzkeb6879402012-04-10 18:28:54 +02002838 output->global =
2839 wl_display_add_global(c->wl_display, &wl_output_interface,
2840 output, bind_output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002841}
2842
Scott Moreau062be7e2012-04-20 13:37:33 -06002843WL_EXPORT void
2844weston_output_do_read_pixels(struct weston_output *output)
2845{
2846 struct weston_read_pixels *r, *next;
2847
2848 glPixelStorei(GL_PACK_ALIGNMENT, 1);
2849 wl_list_for_each_safe(r, next, &output->read_pixels_list, link) {
2850 glReadPixels(r->x, r->y, r->width, r->height,
2851 output->compositor->read_format,
2852 GL_UNSIGNED_BYTE, r->data);
2853 r->done(r, output);
2854 }
2855}
2856
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01002857static void
Kristian Høgsberga8873122011-11-23 10:39:34 -05002858compositor_bind(struct wl_client *client,
2859 void *data, uint32_t version, uint32_t id)
2860{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002861 struct weston_compositor *compositor = data;
Kristian Høgsberga8873122011-11-23 10:39:34 -05002862
2863 wl_client_add_object(client, &wl_compositor_interface,
2864 &compositor_interface, id, compositor);
2865}
2866
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04002867static void
Martin Minarikf12c2872012-06-11 00:57:39 +02002868log_uname(void)
2869{
2870 struct utsname usys;
2871
2872 uname(&usys);
2873
2874 weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release,
2875 usys.version, usys.machine);
2876}
2877
2878static void
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04002879log_extensions(const char *name, const char *extensions)
2880{
2881 const char *p, *end;
2882 int l;
2883
2884 l = weston_log("%s:", name);
2885 p = extensions;
2886 while (*p) {
2887 end = strchrnul(p, ' ');
2888 if (l + (end - p) > 78)
Pekka Paalanen4e4167d2012-06-11 14:06:05 +03002889 l = weston_log_continue("\n" STAMP_SPACE "%.*s",
2890 end - p, p);
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04002891 else
2892 l += weston_log_continue(" %.*s", end - p, p);
2893 for (p = end; isspace(*p); p++)
2894 ;
2895 }
2896 weston_log_continue("\n");
2897}
2898
Pekka Paalanen4e4167d2012-06-11 14:06:05 +03002899static void
2900log_egl_gl_info(EGLDisplay egldpy)
2901{
2902 const char *str;
2903
2904 str = eglQueryString(egldpy, EGL_VERSION);
2905 weston_log("EGL version: %s\n", str ? str : "(null)");
2906
2907 str = eglQueryString(egldpy, EGL_VENDOR);
2908 weston_log("EGL vendor: %s\n", str ? str : "(null)");
2909
2910 str = eglQueryString(egldpy, EGL_CLIENT_APIS);
2911 weston_log("EGL client APIs: %s\n", str ? str : "(null)");
2912
2913 str = eglQueryString(egldpy, EGL_EXTENSIONS);
2914 log_extensions("EGL extensions", str ? str : "(null)");
2915
2916 str = (char *)glGetString(GL_VERSION);
2917 weston_log("GL version: %s\n", str ? str : "(null)");
2918
2919 str = (char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
2920 weston_log("GLSL version: %s\n", str ? str : "(null)");
2921
2922 str = (char *)glGetString(GL_VENDOR);
2923 weston_log("GL vendor: %s\n", str ? str : "(null)");
2924
2925 str = (char *)glGetString(GL_RENDERER);
2926 weston_log("GL renderer: %s\n", str ? str : "(null)");
2927
2928 str = (char *)glGetString(GL_EXTENSIONS);
2929 log_extensions("GL extensions", str ? str : "(null)");
2930}
2931
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002932WL_EXPORT int
Daniel Stonebaf43592012-06-01 11:11:10 -04002933weston_compositor_init(struct weston_compositor *ec,
2934 struct wl_display *display,
2935 int argc,
Daniel Stonec1be8e52012-06-01 11:14:02 -04002936 char *argv[],
2937 const char *config_file)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002938{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002939 struct wl_event_loop *loop;
Kristian Høgsbergd711d0c2011-01-14 17:28:21 -05002940 const char *extensions;
Daniel Stonee2ef43a2012-06-01 12:14:05 +01002941 struct xkb_rule_names xkb_names;
2942 const struct config_key keyboard_config_keys[] = {
2943 { "keymap_rules", CONFIG_KEY_STRING, &xkb_names.rules },
2944 { "keymap_model", CONFIG_KEY_STRING, &xkb_names.model },
2945 { "keymap_layout", CONFIG_KEY_STRING, &xkb_names.layout },
2946 { "keymap_variant", CONFIG_KEY_STRING, &xkb_names.variant },
2947 { "keymap_options", CONFIG_KEY_STRING, &xkb_names.options },
2948 };
2949 const struct config_section cs[] = {
2950 { "keyboard",
2951 keyboard_config_keys, ARRAY_LENGTH(keyboard_config_keys) },
2952 };
2953
2954 memset(&xkb_names, 0, sizeof(xkb_names));
2955 parse_config_file(config_file, cs, ARRAY_LENGTH(cs), ec);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002956
Kristian Høgsbergf9212892008-10-11 18:40:23 -04002957 ec->wl_display = display;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04002958 wl_signal_init(&ec->destroy_signal);
2959 wl_signal_init(&ec->activate_signal);
2960 wl_signal_init(&ec->lock_signal);
2961 wl_signal_init(&ec->unlock_signal);
Benjamin Franzkebfeda132012-01-30 14:04:04 +01002962 ec->launcher_sock = weston_environment_get_fd("WESTON_LAUNCHER_SOCK");
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002963
Casey Dahlin58ba1372012-04-19 22:50:08 -04002964 ec->output_id_pool = 0;
2965
Kristian Høgsberga8873122011-11-23 10:39:34 -05002966 if (!wl_display_add_global(display, &wl_compositor_interface,
2967 ec, compositor_bind))
2968 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05002969
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04002970 wl_display_init_shm(display);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002971
Pekka Paalanen4e4167d2012-06-11 14:06:05 +03002972 log_egl_gl_info(ec->display);
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04002973
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002974 ec->image_target_texture_2d =
2975 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
2976 ec->image_target_renderbuffer_storage = (void *)
2977 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
2978 ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
2979 ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
2980 ec->bind_display =
2981 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
2982 ec->unbind_display =
2983 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
2984
2985 extensions = (const char *) glGetString(GL_EXTENSIONS);
Pekka Paalanen299e58d2012-04-12 14:45:35 +03002986 if (!extensions) {
Martin Minarik6d118362012-06-07 18:01:59 +02002987 weston_log("Retrieving GL extension string failed.\n");
Pekka Paalanen299e58d2012-04-12 14:45:35 +03002988 return -1;
2989 }
2990
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002991 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
Martin Minarik6d118362012-06-07 18:01:59 +02002992 weston_log("GL_EXT_texture_format_BGRA8888 not available\n");
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002993 return -1;
2994 }
2995
Pekka Paalanena1d57db2012-04-17 15:02:08 +03002996 if (strstr(extensions, "GL_EXT_read_format_bgra"))
2997 ec->read_format = GL_BGRA_EXT;
2998 else
2999 ec->read_format = GL_RGBA;
Kristian Høgsbergf9247dd2012-03-27 15:25:46 -04003000
Pekka Paalanen52bfbaa2012-04-11 16:19:37 +03003001 if (strstr(extensions, "GL_EXT_unpack_subimage"))
3002 ec->has_unpack_subimage = 1;
Kristian Høgsbergfb6de222012-03-27 17:10:13 -04003003
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003004 extensions =
3005 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
Pekka Paalanen299e58d2012-04-12 14:45:35 +03003006 if (!extensions) {
Martin Minarik6d118362012-06-07 18:01:59 +02003007 weston_log("Retrieving EGL extension string failed.\n");
Pekka Paalanen299e58d2012-04-12 14:45:35 +03003008 return -1;
3009 }
3010
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003011 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
3012 ec->has_bind_display = 1;
3013 if (ec->has_bind_display)
3014 ec->bind_display(ec->display, ec->wl_display);
Kristian Høgsberg3d5bae02010-10-06 21:17:40 -04003015
Kristian Høgsberg201a9042008-12-10 00:40:50 -05003016 wl_list_init(&ec->surface_list);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05003017 wl_list_init(&ec->layer_list);
Daniel Stone37816df2012-05-16 18:45:18 +01003018 wl_list_init(&ec->seat_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05003019 wl_list_init(&ec->output_list);
Daniel Stone325fc2d2012-05-30 16:31:58 +01003020 wl_list_init(&ec->key_binding_list);
3021 wl_list_init(&ec->button_binding_list);
3022 wl_list_init(&ec->axis_binding_list);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003023 weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04003024 ec->fade.animation.frame = fade_frame;
3025 wl_list_init(&ec->fade.animation.link);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04003026
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05003027 weston_layer_init(&ec->fade_layer, &ec->layer_list);
3028 weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
3029
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003030 screenshooter_create(ec);
Scott Moreau7a1b32a2012-05-27 14:25:02 -06003031 text_cursor_position_notifier_create(ec);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003032
Scott Moreauff1db4a2012-04-17 19:06:18 -06003033 ec->ping_handler = NULL;
3034
Kristian Høgsbergdade6492012-01-04 21:47:30 -05003035 wl_data_device_manager_init(ec->wl_display);
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04003036
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003037 glActiveTexture(GL_TEXTURE0);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04003038
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003039 if (weston_shader_init(&ec->texture_shader,
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04003040 vertex_shader, texture_fragment_shader) < 0)
Kristian Høgsberga9468212010-06-14 21:03:11 -04003041 return -1;
Pekka Paalanenf55f5442012-02-02 16:49:05 +02003042 if (weston_shader_init(&ec->solid_shader,
3043 vertex_shader, solid_fragment_shader) < 0)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04003044 return -1;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05003045
Daniel Stonee2ef43a2012-06-01 12:14:05 +01003046 weston_compositor_xkb_init(ec, &xkb_names);
3047
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05003048 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04003049 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
Pekka Paalanen7296e792011-12-07 16:22:00 +02003050 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04003051
Kristian Høgsberg7ea10862012-03-05 17:49:30 -05003052 ec->input_loop = wl_event_loop_create();
3053
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003054 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04003055
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003056 return 0;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003057}
3058
Benjamin Franzkeb8263022011-08-30 11:32:47 +02003059WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003060weston_compositor_shutdown(struct weston_compositor *ec)
Matt Roper361d2ad2011-08-29 13:52:23 -07003061{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003062 struct weston_output *output, *next;
Matt Roper361d2ad2011-08-29 13:52:23 -07003063
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003064 wl_event_source_remove(ec->idle_source);
Jonas Ådahlc97af922012-03-28 22:36:09 +02003065 if (ec->input_loop_source)
3066 wl_event_source_remove(ec->input_loop_source);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003067
Matt Roper361d2ad2011-08-29 13:52:23 -07003068 /* Destroy all outputs associated with this compositor */
Tiago Vignattib303a1d2011-12-18 22:27:40 +02003069 wl_list_for_each_safe(output, next, &ec->output_list, link)
Matt Roper361d2ad2011-08-29 13:52:23 -07003070 output->destroy(output);
Pekka Paalanen4738f3b2012-01-02 15:47:07 +02003071
Daniel Stone325fc2d2012-05-30 16:31:58 +01003072 weston_binding_list_destroy_all(&ec->key_binding_list);
3073 weston_binding_list_destroy_all(&ec->button_binding_list);
3074 weston_binding_list_destroy_all(&ec->axis_binding_list);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003075
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003076 wl_array_release(&ec->vertices);
3077 wl_array_release(&ec->indices);
Jonas Ådahlc97af922012-03-28 22:36:09 +02003078
3079 wl_event_loop_destroy(ec->input_loop);
Matt Roper361d2ad2011-08-29 13:52:23 -07003080}
3081
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003082static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003083{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003084 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003085
Martin Minarik6d118362012-06-07 18:01:59 +02003086 weston_log("caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003087 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003088
3089 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003090}
3091
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003092static void
3093on_segv_signal(int s, siginfo_t *siginfo, void *context)
3094{
3095 void *buffer[32];
3096 int i, count;
3097 Dl_info info;
3098
Martin Minarik6d118362012-06-07 18:01:59 +02003099 weston_log("caught segv\n");
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003100
3101 count = backtrace(buffer, ARRAY_LENGTH(buffer));
3102 for (i = 0; i < count; i++) {
3103 dladdr(buffer[i], &info);
Martin Minarik6d118362012-06-07 18:01:59 +02003104 weston_log(" [%016lx] %s (%s)\n",
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003105 (long) buffer[i],
3106 info.dli_sname ? info.dli_sname : "--",
3107 info.dli_fname);
3108 }
3109
3110 longjmp(segv_jmp_buf, 1);
3111}
3112
3113
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003114static void *
3115load_module(const char *name, const char *entrypoint, void **handle)
3116{
3117 char path[PATH_MAX];
3118 void *module, *init;
3119
3120 if (name[0] != '/')
Chad Versacebf381902012-05-23 23:42:15 -07003121 snprintf(path, sizeof path, "%s/%s", MODULEDIR, name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003122 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02003123 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003124
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003125 weston_log("Loading module '%s'\n", path);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003126 module = dlopen(path, RTLD_LAZY);
3127 if (!module) {
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003128 weston_log("Failed to load module: %s\n", dlerror());
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003129 return NULL;
3130 }
3131
3132 init = dlsym(module, entrypoint);
3133 if (!init) {
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003134 weston_log("Failed to lookup init function: %s\n", dlerror());
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003135 return NULL;
3136 }
3137
3138 return init;
3139}
3140
Pekka Paalanen78a0b572012-06-06 16:59:44 +03003141static const char xdg_error_message[] =
3142 "fatal: environment variable XDG_RUNTIME_DIR is not set.\n"
3143 "Refer to your distribution on how to get it, or\n"
3144 "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n"
3145 "on how to implement it.\n";
3146
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003147int main(int argc, char *argv[])
3148{
Pekka Paalanen3ab72692012-06-08 17:27:28 +03003149 int ret = EXIT_SUCCESS;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003150 struct wl_display *display;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003151 struct weston_compositor *ec;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003152 struct wl_event_source *signals[4];
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003153 struct wl_event_loop *loop;
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003154 struct sigaction segv_action;
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003155 void *shell_module, *backend_module, *xserver_module;
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003156 int (*module_init)(struct weston_compositor *ec);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003157 struct weston_compositor
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003158 *(*backend_init)(struct wl_display *display,
Daniel Stonec1be8e52012-06-01 11:14:02 -04003159 int argc, char *argv[], const char *config_file);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003160 int i;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003161 char *backend = NULL;
3162 char *shell = NULL;
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003163 char *module = NULL;
Martin Minarik19e6f262012-06-07 13:08:46 +02003164 char *log = NULL;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003165 int32_t idle_time = 300;
Scott Moreaue17f6102012-04-25 10:03:06 -06003166 int32_t xserver = 0;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003167 char *socket_name = NULL;
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003168 char *config_file;
3169
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04003170 const struct config_key shell_config_keys[] = {
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003171 { "type", CONFIG_KEY_STRING, &shell },
3172 };
3173
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04003174 const struct config_section cs[] = {
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003175 { "shell",
3176 shell_config_keys, ARRAY_LENGTH(shell_config_keys) },
3177 };
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04003178
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003179 const struct weston_option core_options[] = {
3180 { WESTON_OPTION_STRING, "backend", 'B', &backend },
3181 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
3182 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003183 { WESTON_OPTION_BOOLEAN, "xserver", 0, &xserver },
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003184 { WESTON_OPTION_STRING, "module", 0, &module },
Martin Minarik19e6f262012-06-07 13:08:46 +02003185 { WESTON_OPTION_STRING, "log", 0, &log },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04003186 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05003187
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003188 argc = parse_options(core_options,
3189 ARRAY_LENGTH(core_options), argc, argv);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003190
Rafal Mielniczuk6e0a7d82012-06-09 15:10:28 +02003191 weston_log_file_open(log);
3192
Pekka Paalanen78a0b572012-06-06 16:59:44 +03003193 if (!getenv("XDG_RUNTIME_DIR")) {
Martin Minarik6d118362012-06-07 18:01:59 +02003194 weston_log(xdg_error_message);
Pekka Paalanen78a0b572012-06-06 16:59:44 +03003195 exit(EXIT_FAILURE);
3196 }
3197
Pekka Paalanenbce4c2b2012-06-11 14:04:21 +03003198 weston_log("%s\n"
3199 STAMP_SPACE "%s\n"
3200 STAMP_SPACE "Bug reports to: %s\n"
3201 STAMP_SPACE "Build: %s\n",
3202 PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT,
Kristian Høgsberg23cf9eb2012-06-11 12:06:30 -04003203 BUILD_ID);
Pekka Paalanen7f4d1a32012-06-11 14:06:03 +03003204 log_uname();
Kristian Høgsberga411c8b2012-06-08 16:16:52 -04003205
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003206 display = wl_display_create();
3207
Tiago Vignatti2116b892011-08-08 05:52:59 -07003208 loop = wl_display_get_event_loop(display);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003209 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
3210 display);
3211 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
3212 display);
3213 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
3214 display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07003215
3216 wl_list_init(&child_process_list);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003217 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
3218 NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05003219
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003220 segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
3221 segv_action.sa_sigaction = on_segv_signal;
Pekka Paalanen8423a892012-01-19 16:48:37 +02003222 sigemptyset(&segv_action.sa_mask);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003223 sigaction(SIGSEGV, &segv_action, NULL);
3224
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003225 if (!backend) {
3226 if (getenv("WAYLAND_DISPLAY"))
3227 backend = "wayland-backend.so";
3228 else if (getenv("DISPLAY"))
3229 backend = "x11-backend.so";
3230 else if (getenv("OPENWFD"))
3231 backend = "openwfd-backend.so";
3232 else
3233 backend = "drm-backend.so";
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04003234 }
3235
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003236 config_file = config_file_path("weston.ini");
3237 parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell);
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003238
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003239 backend_init = load_module(backend, "backend_init", &backend_module);
3240 if (!backend_init)
3241 exit(EXIT_FAILURE);
Kristian Høgsberga9410222011-01-14 17:22:35 -05003242
Daniel Stonec1be8e52012-06-01 11:14:02 -04003243 ec = backend_init(display, argc, argv, config_file);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05003244 if (ec == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02003245 weston_log("failed to create compositor\n");
Kristian Høgsberg841883b2008-12-05 11:19:56 -05003246 exit(EXIT_FAILURE);
3247 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04003248
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003249 for (i = 1; argv[i]; i++)
Martin Minarik6d118362012-06-07 18:01:59 +02003250 weston_log("unhandled option: %s\n", argv[i]);
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003251 if (argv[1])
3252 exit(EXIT_FAILURE);
3253
Daniel Stonec1be8e52012-06-01 11:14:02 -04003254 free(config_file);
Daniel Stone855028f2012-05-01 20:37:10 +01003255
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003256 ec->option_idle_time = idle_time;
3257 ec->idle_time = idle_time;
Pekka Paalanen7296e792011-12-07 16:22:00 +02003258
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003259 module_init = NULL;
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003260 if (xserver)
Tiago Vignatti629ce232012-05-23 23:04:14 +03003261 module_init = load_module("xwayland.so",
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003262 "weston_xserver_init",
3263 &xserver_module);
3264 if (module_init && module_init(ec) < 0)
3265 exit(EXIT_FAILURE);
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003266
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003267 if (!shell)
3268 shell = "desktop-shell.so";
3269 module_init = load_module(shell, "shell_init", &shell_module);
3270 if (!module_init || module_init(ec) < 0)
3271 exit(EXIT_FAILURE);
3272
3273
3274 module_init = NULL;
3275 if (module)
3276 module_init = load_module(module, "module_init", NULL);
3277 if (module_init && module_init(ec) < 0)
Tiago Vignattie4faa2a2012-04-16 17:31:44 +03003278 exit(EXIT_FAILURE);
3279
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003280 if (wl_display_add_socket(display, socket_name)) {
Martin Minarik6d118362012-06-07 18:01:59 +02003281 weston_log("failed to add socket: %m\n");
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003282 exit(EXIT_FAILURE);
3283 }
3284
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02003285 weston_compositor_dpms_on(ec);
Pekka Paalanenc0444e32012-01-05 16:28:21 +02003286 weston_compositor_wake(ec);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003287 if (setjmp(segv_jmp_buf) == 0)
3288 wl_display_run(display);
Pekka Paalanen3ab72692012-06-08 17:27:28 +03003289 else
3290 ret = EXIT_FAILURE;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003291
Pekka Paalanen0135abe2012-01-03 10:01:20 +02003292 /* prevent further rendering while shutting down */
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05003293 ec->state = WESTON_COMPOSITOR_SLEEPING;
Pekka Paalanen0135abe2012-01-03 10:01:20 +02003294
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003295 wl_signal_emit(&ec->destroy_signal, ec);
Pekka Paalanen3c647232011-12-22 13:43:43 +02003296
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003297 if (ec->has_bind_display)
3298 ec->unbind_display(ec->display, display);
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05003299
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003300 for (i = ARRAY_LENGTH(signals); i;)
3301 wl_event_source_remove(signals[--i]);
3302
Daniel Stone855028f2012-05-01 20:37:10 +01003303 weston_compositor_xkb_destroy(ec);
3304
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05003305 ec->destroy(ec);
Tiago Vignatti9e2be082011-12-19 00:04:46 +02003306 wl_display_destroy(display);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05003307
Martin Minarik19e6f262012-06-07 13:08:46 +02003308 weston_log_file_close();
3309
Pekka Paalanen3ab72692012-06-08 17:27:28 +03003310 return ret;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003311}