blob: 2d03a140e614b585dcac23750a179329860d95da [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>
Martin Minarik37032f82012-06-18 20:15:18 +020042#include <sys/stat.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040043#include <unistd.h>
Kristian Høgsberg54879822008-11-23 17:07:32 -050044#include <math.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040045#include <linux/input.h>
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -040046#include <dlfcn.h>
Kristian Høgsberg85449032011-05-02 12:11:07 -040047#include <signal.h>
Kristian Høgsberg0690da62012-01-16 11:53:54 -050048#include <setjmp.h>
Kristian Høgsberga411c8b2012-06-08 16:16:52 -040049#include <sys/time.h>
50#include <time.h>
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -040051#include <ctype.h>
Kristian Høgsberg890bc052008-12-30 14:31:33 -050052
Pekka Paalanen50719bc2011-11-22 14:18:50 +020053#include <wayland-server.h>
Kristian Høgsberg82863022010-06-04 21:52:02 -040054#include "compositor.h"
Pekka Paalanen51aaf642012-05-30 15:53:41 +030055#include "../shared/os-compatibility.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øgsberg7b884bc2012-07-31 14:32:01 -040059static struct weston_compositor *segv_compositor;
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øgsberga85b4fb2012-06-20 09:24:35 -0400183update_shm_texture(struct weston_surface *surface);
184
185static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400186surface_handle_buffer_destroy(struct wl_listener *listener, void *data)
Benjamin Franzke06286262011-05-06 19:12:33 +0200187{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500188 struct weston_surface *es =
189 container_of(listener, struct weston_surface,
190 buffer_destroy_listener);
Benjamin Franzke06286262011-05-06 19:12:33 +0200191
Kristian Høgsberga85b4fb2012-06-20 09:24:35 -0400192 if (es->buffer && wl_buffer_is_shm(es->buffer))
193 update_shm_texture(es);
194
Kristian Høgsberg24596942011-10-24 17:51:02 -0400195 es->buffer = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200196}
197
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500198static const pixman_region32_data_t undef_region_data;
199
200static void
201undef_region(pixman_region32_t *region)
202{
Kristian Høgsberg66a099b2012-05-29 16:49:45 -0400203 if (region->data != &undef_region_data)
204 pixman_region32_fini(region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500205 region->data = (pixman_region32_data_t *) &undef_region_data;
206}
207
208static int
209region_is_undefined(pixman_region32_t *region)
210{
211 return region->data == &undef_region_data;
212}
213
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +0200214static void
215empty_region(pixman_region32_t *region)
216{
217 if (!region_is_undefined(region))
218 pixman_region32_fini(region);
219
220 pixman_region32_init(region);
221}
222
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500223WL_EXPORT struct weston_surface *
Kristian Høgsberg18c93002012-01-27 11:58:31 -0500224weston_surface_create(struct weston_compositor *compositor)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500225{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500226 struct weston_surface *surface;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400227
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200228 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400229 if (surface == NULL)
230 return NULL;
231
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400232 wl_signal_init(&surface->surface.resource.destroy_signal);
Kristian Høgsberg48891542012-02-23 17:38:33 -0500233
Kristian Høgsbergf6b14712011-01-06 15:32:14 -0500234 wl_list_init(&surface->link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500235 wl_list_init(&surface->layer_link);
Kristian Høgsbergc551bd22010-12-06 16:43:16 -0500236
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400237 surface->surface.resource.client = NULL;
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400238
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500239 surface->compositor = compositor;
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400240 surface->alpha = 1.0;
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400241 surface->blend = 1;
Kristian Høgsberg0b0c2bb2012-05-15 23:16:53 -0400242 surface->opaque_rect[0] = 0.0;
243 surface->opaque_rect[1] = 0.0;
244 surface->opaque_rect[2] = 0.0;
245 surface->opaque_rect[3] = 0.0;
Juan Zhao46436612012-03-20 01:48:46 +0800246 surface->pitch = 1;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400247
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200248 surface->num_textures = 0;
249 surface->num_images = 0;
250
Benjamin Franzke06286262011-05-06 19:12:33 +0200251 surface->buffer = NULL;
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400252 surface->output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200253
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400254 pixman_region32_init(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500255 pixman_region32_init(&surface->opaque);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500256 pixman_region32_init(&surface->clip);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500257 undef_region(&surface->input);
Pekka Paalanen730d87e2012-02-09 16:39:38 +0200258 pixman_region32_init(&surface->transform.opaque);
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500259 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400260
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -0400261 surface->buffer_destroy_listener.notify =
262 surface_handle_buffer_destroy;
Benjamin Franzke06286262011-05-06 19:12:33 +0200263
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200264 wl_list_init(&surface->geometry.transformation_list);
Pekka Paalanencd403622012-01-25 13:37:39 +0200265 wl_list_insert(&surface->geometry.transformation_list,
266 &surface->transform.position.link);
267 weston_matrix_init(&surface->transform.position.matrix);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200268 pixman_region32_init(&surface->transform.boundingbox);
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200269 surface->geometry.dirty = 1;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500270
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400271 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500272}
273
Alex Wu8811bf92012-02-28 18:07:54 +0800274WL_EXPORT void
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500275weston_surface_set_color(struct weston_surface *surface,
276 GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
277{
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500278 surface->color[0] = red;
279 surface->color[1] = green;
280 surface->color[2] = blue;
281 surface->color[3] = alpha;
282 surface->shader = &surface->compositor->solid_shader;
283}
284
Kristian Høgsberge4c1a5f2012-06-18 13:17:32 -0400285WL_EXPORT void
286weston_surface_to_global_float(struct weston_surface *surface,
287 GLfloat sx, GLfloat sy, GLfloat *x, GLfloat *y)
Pekka Paalanenece8a012012-02-08 15:23:15 +0200288{
289 if (surface->transform.enabled) {
290 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
291
292 weston_matrix_transform(&surface->transform.matrix, &v);
293
294 if (fabsf(v.f[3]) < 1e-6) {
Martin Minarik6d118362012-06-07 18:01:59 +0200295 weston_log("warning: numerical instability in "
Pekka Paalanenece8a012012-02-08 15:23:15 +0200296 "weston_surface_to_global(), divisor = %g\n",
297 v.f[3]);
298 *x = 0;
299 *y = 0;
300 return;
301 }
302
303 *x = v.f[0] / v.f[3];
304 *y = v.f[1] / v.f[3];
305 } else {
306 *x = sx + surface->geometry.x;
307 *y = sy + surface->geometry.y;
308 }
309}
310
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500311WL_EXPORT void
Kristian Høgsberg323ee042012-02-17 12:45:43 -0500312weston_surface_damage_below(struct weston_surface *surface)
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200313{
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500314 struct weston_compositor *compositor = surface->compositor;
315 pixman_region32_t damage;
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200316
Kristian Høgsbergd553bfc2012-06-18 22:37:35 -0400317 if (surface->plane != WESTON_PLANE_PRIMARY)
318 return;
319
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500320 pixman_region32_init(&damage);
321 pixman_region32_subtract(&damage, &surface->transform.boundingbox,
322 &surface->clip);
323 pixman_region32_union(&compositor->damage,
324 &compositor->damage, &damage);
325 pixman_region32_fini(&damage);
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200326}
327
328static void
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200329surface_compute_bbox(struct weston_surface *surface, int32_t sx, int32_t sy,
330 int32_t width, int32_t height,
331 pixman_region32_t *bbox)
332{
Pekka Paalanen219b9822012-02-08 15:38:37 +0200333 GLfloat min_x = HUGE_VALF, min_y = HUGE_VALF;
334 GLfloat max_x = -HUGE_VALF, max_y = -HUGE_VALF;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200335 int32_t s[4][2] = {
336 { sx, sy },
337 { sx, sy + height },
338 { sx + width, sy },
339 { sx + width, sy + height }
340 };
Pekka Paalanen219b9822012-02-08 15:38:37 +0200341 GLfloat int_x, int_y;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200342 int i;
343
344 for (i = 0; i < 4; ++i) {
Pekka Paalanen219b9822012-02-08 15:38:37 +0200345 GLfloat x, y;
Kristian Høgsberge4c1a5f2012-06-18 13:17:32 -0400346 weston_surface_to_global_float(surface,
347 s[i][0], s[i][1], &x, &y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200348 if (x < min_x)
349 min_x = x;
350 if (x > max_x)
351 max_x = x;
352 if (y < min_y)
353 min_y = y;
354 if (y > max_y)
355 max_y = y;
356 }
357
Pekka Paalanen219b9822012-02-08 15:38:37 +0200358 int_x = floorf(min_x);
359 int_y = floorf(min_y);
360 pixman_region32_init_rect(bbox, int_x, int_y,
361 ceilf(max_x) - int_x, ceilf(max_y) - int_y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200362}
363
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200364static void
365weston_surface_update_transform_disable(struct weston_surface *surface)
366{
367 surface->transform.enabled = 0;
368
Pekka Paalanencc2f8682012-02-13 10:34:04 +0200369 /* round off fractions when not transformed */
370 surface->geometry.x = roundf(surface->geometry.x);
371 surface->geometry.y = roundf(surface->geometry.y);
372
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200373 pixman_region32_init_rect(&surface->transform.boundingbox,
374 surface->geometry.x,
375 surface->geometry.y,
376 surface->geometry.width,
377 surface->geometry.height);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500378
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400379 if (surface->alpha == 1.0) {
Kristian Høgsberg3b4af202012-02-28 09:19:39 -0500380 pixman_region32_copy(&surface->transform.opaque,
381 &surface->opaque);
382 pixman_region32_translate(&surface->transform.opaque,
383 surface->geometry.x,
384 surface->geometry.y);
385 }
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200386}
387
388static int
389weston_surface_update_transform_enable(struct weston_surface *surface)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200390{
391 struct weston_matrix *matrix = &surface->transform.matrix;
392 struct weston_matrix *inverse = &surface->transform.inverse;
393 struct weston_transform *tform;
394
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200395 surface->transform.enabled = 1;
396
397 /* Otherwise identity matrix, but with x and y translation. */
398 surface->transform.position.matrix.d[12] = surface->geometry.x;
399 surface->transform.position.matrix.d[13] = surface->geometry.y;
400
401 weston_matrix_init(matrix);
402 wl_list_for_each(tform, &surface->geometry.transformation_list, link)
403 weston_matrix_multiply(matrix, &tform->matrix);
404
405 if (weston_matrix_invert(inverse, matrix) < 0) {
406 /* Oops, bad total transformation, not invertible */
Martin Minarik6d118362012-06-07 18:01:59 +0200407 weston_log("error: weston_surface %p"
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200408 " transformation not invertible.\n", surface);
409 return -1;
410 }
411
412 surface_compute_bbox(surface, 0, 0, surface->geometry.width,
413 surface->geometry.height,
414 &surface->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500415
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200416 return 0;
417}
418
419WL_EXPORT void
420weston_surface_update_transform(struct weston_surface *surface)
421{
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200422 if (!surface->geometry.dirty)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200423 return;
424
Pekka Paalanenbc0b7e72012-01-24 09:53:37 +0200425 surface->geometry.dirty = 0;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200426
Kristian Høgsberg323ee042012-02-17 12:45:43 -0500427 weston_surface_damage_below(surface);
Pekka Paalanen96516782012-02-09 15:32:15 +0200428
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200429 pixman_region32_fini(&surface->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500430 pixman_region32_fini(&surface->transform.opaque);
431 pixman_region32_init(&surface->transform.opaque);
432
433 if (region_is_undefined(&surface->input))
434 pixman_region32_init_rect(&surface->input, 0, 0,
435 surface->geometry.width,
436 surface->geometry.height);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200437
Pekka Paalanencd403622012-01-25 13:37:39 +0200438 /* transform.position is always in transformation_list */
439 if (surface->geometry.transformation_list.next ==
440 &surface->transform.position.link &&
441 surface->geometry.transformation_list.prev ==
442 &surface->transform.position.link) {
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200443 weston_surface_update_transform_disable(surface);
444 } else {
445 if (weston_surface_update_transform_enable(surface) < 0)
446 weston_surface_update_transform_disable(surface);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200447 }
Pekka Paalanen96516782012-02-09 15:32:15 +0200448
Kristian Høgsbergf1ea63f2012-07-18 12:02:51 -0400449 weston_surface_damage_below(surface);
Pekka Paalanen96516782012-02-09 15:32:15 +0200450
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300451 if (weston_surface_is_mapped(surface))
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +0200452 weston_surface_assign_output(surface);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200453}
454
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200455WL_EXPORT void
Daniel Stonebd3489b2012-05-08 17:17:53 +0100456weston_surface_to_global_fixed(struct weston_surface *surface,
457 wl_fixed_t sx, wl_fixed_t sy,
458 wl_fixed_t *x, wl_fixed_t *y)
459{
460 GLfloat xf, yf;
461
462 weston_surface_to_global_float(surface,
463 wl_fixed_to_double(sx),
464 wl_fixed_to_double(sy),
465 &xf, &yf);
466 *x = wl_fixed_from_double(xf);
467 *y = wl_fixed_from_double(yf);
468}
469
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200470static void
471surface_from_global_float(struct weston_surface *surface,
Daniel Stonebd3489b2012-05-08 17:17:53 +0100472 GLfloat x, GLfloat y, GLfloat *sx, GLfloat *sy)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200473{
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200474 if (surface->transform.enabled) {
475 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
476
477 weston_matrix_transform(&surface->transform.inverse, &v);
478
479 if (fabsf(v.f[3]) < 1e-6) {
Martin Minarik6d118362012-06-07 18:01:59 +0200480 weston_log("warning: numerical instability in "
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200481 "weston_surface_from_global(), divisor = %g\n",
482 v.f[3]);
483 *sx = 0;
484 *sy = 0;
485 return;
486 }
487
Pekka Paalanencd403622012-01-25 13:37:39 +0200488 *sx = v.f[0] / v.f[3];
489 *sy = v.f[1] / v.f[3];
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200490 } else {
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200491 *sx = x - surface->geometry.x;
492 *sy = y - surface->geometry.y;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +0200493 }
494}
495
496WL_EXPORT void
Daniel Stonebd3489b2012-05-08 17:17:53 +0100497weston_surface_from_global_fixed(struct weston_surface *surface,
498 wl_fixed_t x, wl_fixed_t y,
499 wl_fixed_t *sx, wl_fixed_t *sy)
500{
501 GLfloat sxf, syf;
502
Daniel Stonebd3489b2012-05-08 17:17:53 +0100503 surface_from_global_float(surface,
504 wl_fixed_to_double(x),
505 wl_fixed_to_double(y),
506 &sxf, &syf);
507 *sx = wl_fixed_from_double(sxf);
508 *sy = wl_fixed_from_double(syf);
509}
510
511WL_EXPORT void
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200512weston_surface_from_global(struct weston_surface *surface,
513 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
514{
515 GLfloat sxf, syf;
516
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200517 surface_from_global_float(surface, x, y, &sxf, &syf);
518 *sx = floorf(sxf);
519 *sy = floorf(syf);
520}
521
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400522WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500523weston_surface_damage(struct weston_surface *surface)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500524{
Kristian Høgsberg460a79b2012-06-18 15:09:11 -0400525 pixman_region32_union_rect(&surface->damage, &surface->damage,
526 0, 0, surface->geometry.width,
527 surface->geometry.height);
Pekka Paalanen2267d452012-01-26 13:12:45 +0200528
529 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500530}
531
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400532WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500533weston_surface_configure(struct weston_surface *surface,
Pekka Paalanenddae03c2012-02-06 14:54:20 +0200534 GLfloat x, GLfloat y, int width, int height)
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400535{
Pekka Paalanenba3cf952012-01-25 16:22:05 +0200536 surface->geometry.x = x;
537 surface->geometry.y = y;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200538 surface->geometry.width = width;
539 surface->geometry.height = height;
Pekka Paalanencd403622012-01-25 13:37:39 +0200540 surface->geometry.dirty = 1;
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400541}
542
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +0200543WL_EXPORT void
544weston_surface_set_position(struct weston_surface *surface,
545 GLfloat x, GLfloat y)
546{
547 surface->geometry.x = x;
548 surface->geometry.y = y;
549 surface->geometry.dirty = 1;
550}
551
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300552WL_EXPORT int
553weston_surface_is_mapped(struct weston_surface *surface)
554{
555 if (surface->output)
556 return 1;
557 else
558 return 0;
559}
560
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400561WL_EXPORT uint32_t
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500562weston_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500563{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400564 struct timeval tv;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500565
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400566 gettimeofday(&tv, NULL);
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500567
Kristian Høgsbergeae5de72012-04-11 22:42:15 -0400568 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500569}
570
Tiago Vignatti9d393522012-02-10 16:26:19 +0200571static struct weston_surface *
572weston_compositor_pick_surface(struct weston_compositor *compositor,
Daniel Stone103db7f2012-05-08 17:17:55 +0100573 wl_fixed_t x, wl_fixed_t y,
574 wl_fixed_t *sx, wl_fixed_t *sy)
Tiago Vignatti9d393522012-02-10 16:26:19 +0200575{
576 struct weston_surface *surface;
577
578 wl_list_for_each(surface, &compositor->surface_list, link) {
Daniel Stone103db7f2012-05-08 17:17:55 +0100579 weston_surface_from_global_fixed(surface, x, y, sx, sy);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500580 if (pixman_region32_contains_point(&surface->input,
Daniel Stone103db7f2012-05-08 17:17:55 +0100581 wl_fixed_to_int(*sx),
582 wl_fixed_to_int(*sy),
583 NULL))
Tiago Vignatti9d393522012-02-10 16:26:19 +0200584 return surface;
585 }
586
587 return NULL;
588}
589
590static void
Daniel Stone37816df2012-05-16 18:45:18 +0100591weston_device_repick(struct wl_seat *seat)
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500592{
Daniel Stone37816df2012-05-16 18:45:18 +0100593 struct weston_seat *ws = (struct weston_seat *) seat;
Scott Moreau447013d2012-02-18 05:05:29 -0700594 const struct wl_pointer_grab_interface *interface;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500595 struct weston_surface *surface, *focus;
596
Daniel Stonee9e92d22012-06-04 11:40:47 +0100597 if (!seat->pointer)
598 return;
599
Daniel Stone37816df2012-05-16 18:45:18 +0100600 surface = weston_compositor_pick_surface(ws->compositor,
601 seat->pointer->x,
602 seat->pointer->y,
603 &seat->pointer->current_x,
604 &seat->pointer->current_y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500605
Daniel Stone37816df2012-05-16 18:45:18 +0100606 if (&surface->surface != seat->pointer->current) {
607 interface = seat->pointer->grab->interface;
Kristian Høgsberg4e99ac42012-06-04 16:12:38 -0400608 seat->pointer->current = &surface->surface;
Daniel Stone37816df2012-05-16 18:45:18 +0100609 interface->focus(seat->pointer->grab, &surface->surface,
610 seat->pointer->current_x,
611 seat->pointer->current_y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500612 }
613
Daniel Stone37816df2012-05-16 18:45:18 +0100614 focus = (struct weston_surface *) seat->pointer->grab->focus;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500615 if (focus)
Daniel Stone37816df2012-05-16 18:45:18 +0100616 weston_surface_from_global_fixed(focus,
617 seat->pointer->x,
618 seat->pointer->y,
619 &seat->pointer->grab->x,
620 &seat->pointer->grab->y);
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -0500621}
622
Kristian Høgsberg4ff5a742012-06-18 16:48:27 -0400623static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500624weston_compositor_repick(struct weston_compositor *compositor)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400625{
Daniel Stone37816df2012-05-16 18:45:18 +0100626 struct weston_seat *seat;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400627
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500628 if (!compositor->focus)
629 return;
630
Daniel Stone37816df2012-05-16 18:45:18 +0100631 wl_list_for_each(seat, &compositor->seat_list, link)
632 weston_device_repick(&seat->seat);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400633}
634
Kristian Høgsbergaf7b1ff2012-06-26 21:19:23 -0400635WL_EXPORT void
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500636weston_surface_unmap(struct weston_surface *surface)
637{
Daniel Stone4dab5db2012-05-30 16:31:53 +0100638 struct weston_seat *seat;
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500639
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500640 weston_surface_damage_below(surface);
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500641 surface->output = NULL;
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500642 wl_list_remove(&surface->layer_link);
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500643
Daniel Stone4dab5db2012-05-30 16:31:53 +0100644 wl_list_for_each(seat, &surface->compositor->seat_list, link) {
Daniel Stonee9e92d22012-06-04 11:40:47 +0100645 if (seat->seat.keyboard &&
646 seat->seat.keyboard->focus == &surface->surface)
Daniel Stone4dab5db2012-05-30 16:31:53 +0100647 wl_keyboard_set_focus(seat->seat.keyboard, NULL);
Daniel Stonee9e92d22012-06-04 11:40:47 +0100648 if (seat->seat.pointer &&
649 seat->seat.pointer->focus == &surface->surface)
Daniel Stone4dab5db2012-05-30 16:31:53 +0100650 wl_pointer_set_focus(seat->seat.pointer,
651 NULL,
652 wl_fixed_from_int(0),
653 wl_fixed_from_int(0));
654 }
Kristian Høgsberg867dec72012-03-01 17:09:37 -0500655
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500656 weston_compositor_schedule_repaint(surface->compositor);
657}
658
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -0400659struct weston_frame_callback {
660 struct wl_resource resource;
661 struct wl_list link;
662};
663
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500664static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400665destroy_surface(struct wl_resource *resource)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500666{
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200667 int i;
668
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500669 struct weston_surface *surface =
670 container_of(resource,
671 struct weston_surface, surface.resource);
672 struct weston_compositor *compositor = surface->compositor;
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -0400673 struct weston_frame_callback *cb, *next;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400674
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +0300675 if (weston_surface_is_mapped(surface))
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -0500676 weston_surface_unmap(surface);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400677
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200678 glDeleteTextures(surface->num_textures, surface->textures);
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200679
Benjamin Franzke06286262011-05-06 19:12:33 +0200680 if (surface->buffer)
681 wl_list_remove(&surface->buffer_destroy_listener.link);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400682
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200683 for (i = 0; i < surface->num_images; i++)
Kristian Høgsberg362b6722012-06-18 15:13:51 -0400684 compositor->destroy_image(compositor->egl_display,
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200685 surface->images[i]);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200686
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200687 pixman_region32_fini(&surface->transform.boundingbox);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200688 pixman_region32_fini(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500689 pixman_region32_fini(&surface->opaque);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500690 pixman_region32_fini(&surface->clip);
Kristian Høgsbergdd631c12012-02-23 16:20:38 -0500691 if (!region_is_undefined(&surface->input))
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500692 pixman_region32_fini(&surface->input);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200693
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -0400694 wl_list_for_each_safe(cb, next, &surface->frame_callback_list, link)
695 wl_resource_destroy(&cb->resource);
696
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400697 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500698}
699
Alex Wu8811bf92012-02-28 18:07:54 +0800700WL_EXPORT void
701weston_surface_destroy(struct weston_surface *surface)
702{
703 /* Not a valid way to destroy a client surface */
704 assert(surface->surface.resource.client == NULL);
705
Kristian Høgsberg9a050af2012-06-07 18:17:42 -0400706 wl_signal_emit(&surface->surface.resource.destroy_signal,
707 &surface->surface.resource);
Alex Wu8811bf92012-02-28 18:07:54 +0800708 destroy_surface(&surface->surface.resource);
709}
710
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100711static void
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200712ensure_textures(struct weston_surface *es, int num_textures)
713{
714 int i;
715
716 if (num_textures <= es->num_textures)
717 return;
718
719 for (i = es->num_textures; i < num_textures; i++) {
720 glGenTextures(1, &es->textures[i]);
721 glBindTexture(GL_TEXTURE_2D, es->textures[i]);
722 glTexParameteri(GL_TEXTURE_2D,
723 GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
724 glTexParameteri(GL_TEXTURE_2D,
725 GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
726 }
727 es->num_textures = num_textures;
728 glBindTexture(GL_TEXTURE_2D, 0);
729}
730
731static void
Kristian Høgsberg8cbfb2a2012-03-27 17:04:59 -0400732weston_surface_attach(struct wl_surface *surface, struct wl_buffer *buffer)
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100733{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500734 struct weston_surface *es = (struct weston_surface *) surface;
735 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg905d7ce2012-07-19 14:20:20 -0400736 EGLint attribs[3], format;
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200737 int i, num_planes;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100738
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300739 if (es->buffer) {
740 weston_buffer_post_release(es->buffer);
741 wl_list_remove(&es->buffer_destroy_listener.link);
742 }
743
744 es->buffer = buffer;
745
746 if (!buffer) {
747 if (weston_surface_is_mapped(es))
748 weston_surface_unmap(es);
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200749 for (i = 0; i < es->num_images; i++) {
750 ec->destroy_image(ec->egl_display, es->images[i]);
751 es->images[i] = NULL;
Kristian Høgsbergb8ceaaa2012-06-19 15:41:12 -0400752 }
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200753 es->num_images = 0;
754 glDeleteTextures(es->num_textures, es->textures);
755 es->num_textures = 0;
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300756 return;
757 }
758
759 buffer->busy_count++;
Kristian Høgsberg27e30522012-04-11 23:18:23 -0400760 wl_signal_add(&es->buffer->resource.destroy_signal,
761 &es->buffer_destroy_listener);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300762
763 if (es->geometry.width != buffer->width ||
764 es->geometry.height != buffer->height) {
765 undef_region(&es->input);
766 pixman_region32_fini(&es->opaque);
767 pixman_region32_init(&es->opaque);
768 }
769
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100770 if (wl_buffer_is_shm(buffer)) {
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200771 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
Gwenole Beauchesne6d030492012-04-20 11:15:51 +0200772 es->shader = &ec->texture_shader_rgba;
Gwenole Beauchesne023f8552012-04-20 11:07:06 +0200773
774 ensure_textures(es, 1);
775 glBindTexture(GL_TEXTURE_2D, es->textures[0]);
Kristian Høgsbergfb6de222012-03-27 17:10:13 -0400776 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
777 es->pitch, es->buffer->height, 0,
778 GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400779 if (wl_shm_buffer_get_format(buffer) == WL_SHM_FORMAT_XRGB8888)
780 es->blend = 0;
781 else
782 es->blend = 1;
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200783 } else if (ec->query_buffer(ec->egl_display, buffer,
Kristian Høgsberg905d7ce2012-07-19 14:20:20 -0400784 EGL_TEXTURE_FORMAT, &format)) {
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200785 for (i = 0; i < es->num_images; i++)
Kristian Høgsberg971cbc82012-07-17 14:21:25 -0400786 ec->destroy_image(ec->egl_display, es->images[i]);
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200787 es->num_images = 0;
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +0300788
Kristian Høgsberg905d7ce2012-07-19 14:20:20 -0400789 switch (format) {
790 case EGL_TEXTURE_RGB:
791 case EGL_TEXTURE_RGBA:
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200792 default:
793 num_planes = 1;
794 es->shader = &ec->texture_shader_rgba;
795 break;
Kristian Høgsberg905d7ce2012-07-19 14:20:20 -0400796 case EGL_TEXTURE_Y_UV_WL:
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200797 num_planes = 2;
798 es->shader = &ec->texture_shader_y_uv;
799 break;
Kristian Høgsberg905d7ce2012-07-19 14:20:20 -0400800 case EGL_TEXTURE_Y_U_V_WL:
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200801 num_planes = 3;
802 es->shader = &ec->texture_shader_y_u_v;
803 break;
Kristian Høgsberg905d7ce2012-07-19 14:20:20 -0400804 case EGL_TEXTURE_Y_XUXV_WL:
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200805 num_planes = 2;
806 es->shader = &ec->texture_shader_y_xuxv;
807 break;
808 }
809
810 ensure_textures(es, num_planes);
811 for (i = 0; i < num_planes; i++) {
812 attribs[0] = EGL_WAYLAND_PLANE_WL;
813 attribs[1] = i;
814 attribs[2] = EGL_NONE;
815 es->images[i] = ec->create_image(ec->egl_display,
816 NULL,
817 EGL_WAYLAND_BUFFER_WL,
818 buffer, attribs);
819 if (!es->images[i])
820 continue;
821 es->num_images++;
822
823 glActiveTexture(GL_TEXTURE0 + i);
824 glBindTexture(GL_TEXTURE_2D, es->textures[i]);
825 ec->image_target_texture_2d(GL_TEXTURE_2D,
826 es->images[i]);
827 }
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400828
Ander Conselvan de Oliveira9390ae32012-03-27 17:36:38 +0300829 es->pitch = buffer->width;
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200830 } else {
831 /* unhandled buffer type */
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100832 }
833}
834
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400835static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500836texture_region(struct weston_surface *es, pixman_region32_t *region)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500837{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500838 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500839 GLfloat *v, inv_width, inv_height;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200840 GLfloat sx, sy;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500841 pixman_box32_t *rectangles;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400842 unsigned int *p;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500843 int i, n;
844
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400845 rectangles = pixman_region32_rectangles(region, &n);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500846 v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
847 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200848 inv_width = 1.0 / es->pitch;
Pekka Paalanen60921e52012-01-25 15:55:43 +0200849 inv_height = 1.0 / es->geometry.height;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400850
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500851 for (i = 0; i < n; i++, v += 16, p += 6) {
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200852 surface_from_global_float(es, rectangles[i].x1,
853 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500854 v[ 0] = rectangles[i].x1;
855 v[ 1] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200856 v[ 2] = sx * inv_width;
857 v[ 3] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500858
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200859 surface_from_global_float(es, rectangles[i].x1,
860 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500861 v[ 4] = rectangles[i].x1;
862 v[ 5] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200863 v[ 6] = sx * inv_width;
864 v[ 7] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500865
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200866 surface_from_global_float(es, rectangles[i].x2,
867 rectangles[i].y1, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500868 v[ 8] = rectangles[i].x2;
869 v[ 9] = rectangles[i].y1;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200870 v[10] = sx * inv_width;
871 v[11] = sy * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500872
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200873 surface_from_global_float(es, rectangles[i].x2,
874 rectangles[i].y2, &sx, &sy);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500875 v[12] = rectangles[i].x2;
876 v[13] = rectangles[i].y2;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200877 v[14] = sx * inv_width;
878 v[15] = sy * inv_height;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500879
880 p[0] = i * 4 + 0;
881 p[1] = i * 4 + 1;
882 p[2] = i * 4 + 2;
883 p[3] = i * 4 + 2;
884 p[4] = i * 4 + 1;
885 p[5] = i * 4 + 3;
886 }
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500887
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400888 return n;
889}
890
Kristian Høgsberg68c479a2012-01-25 23:32:28 -0500891WL_EXPORT void
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500892weston_surface_draw(struct weston_surface *es, struct weston_output *output,
893 pixman_region32_t *damage)
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400894{
Scott Moreau9fb98242012-05-22 10:18:50 -0600895 GLfloat surface_rect[4] = { 0.0, 1.0, 0.0, 1.0 };
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500896 struct weston_compositor *ec = es->compositor;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400897 GLfloat *v;
898 pixman_region32_t repaint;
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400899 GLint filter;
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200900 int i, n;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400901
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200902 pixman_region32_init(&repaint);
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -0500903 pixman_region32_intersect(&repaint,
904 &es->transform.boundingbox, damage);
905 pixman_region32_subtract(&repaint, &repaint, &es->clip);
Pekka Paalanenc7b45f62012-02-06 12:16:07 +0200906
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400907 if (!pixman_region32_not_empty(&repaint))
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200908 goto out;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400909
Kristian Høgsberg101cb652012-02-17 10:45:16 -0500910 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
Scott Moreau9fb98242012-05-22 10:18:50 -0600911 if (es->blend || es->alpha < 1.0)
Kristian Høgsbergd6ad1222012-05-17 11:11:15 -0400912 glEnable(GL_BLEND);
913 else
914 glDisable(GL_BLEND);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400915
Kristian Høgsberg07632622012-01-25 23:02:06 -0500916 if (ec->current_shader != es->shader) {
917 glUseProgram(es->shader->program);
Kristian Høgsberg07632622012-01-25 23:02:06 -0500918 ec->current_shader = es->shader;
919 }
920
Kristian Høgsberg0452abc2012-01-31 15:38:36 -0500921 glUniformMatrix4fv(es->shader->proj_uniform,
922 1, GL_FALSE, output->matrix.d);
Pekka Paalanenf55f5442012-02-02 16:49:05 +0200923 glUniform4fv(es->shader->color_uniform, 1, es->color);
Kristian Høgsberga416fa12012-05-21 14:06:52 -0400924 glUniform1f(es->shader->alpha_uniform, es->alpha);
Pekka Paalanenf55f5442012-02-02 16:49:05 +0200925 glUniform1f(es->shader->texwidth_uniform,
926 (GLfloat)es->geometry.width / es->pitch);
Scott Moreau9fb98242012-05-22 10:18:50 -0600927 if (es->blend)
928 glUniform4fv(es->shader->opaque_uniform, 1, es->opaque_rect);
929 else
930 glUniform4fv(es->shader->opaque_uniform, 1, surface_rect);
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200931
Scott Moreauccbf29d2012-02-22 14:21:41 -0700932 if (es->transform.enabled || output->zoom.active)
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400933 filter = GL_LINEAR;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200934 else
Pekka Paalanenc61eca62012-01-06 14:10:06 +0200935 filter = GL_NEAREST;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +0200936
937 n = texture_region(es, &repaint);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400938
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +0200939 for (i = 0; i < es->num_textures; i++) {
940 glUniform1i(es->shader->tex_uniforms[i], i);
941 glActiveTexture(GL_TEXTURE0 + i);
942 glBindTexture(GL_TEXTURE_2D, es->textures[i]);
943 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
944 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
945 }
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400946
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500947 v = ec->vertices.data;
948 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
949 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400950 glEnableVertexAttribArray(0);
951 glEnableVertexAttribArray(1);
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200952
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500953 glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
954
Pekka Paalanen3df327f2012-01-24 15:53:35 +0200955 glDisableVertexAttribArray(1);
956 glDisableVertexAttribArray(0);
957
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500958 ec->vertices.size = 0;
959 ec->indices.size = 0;
Pekka Paalanena9f8a212012-01-26 11:28:08 +0200960
961out:
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500962 pixman_region32_fini(&repaint);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500963}
964
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500965WL_EXPORT void
966weston_surface_restack(struct weston_surface *surface, struct wl_list *below)
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400967{
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500968 wl_list_remove(&surface->layer_link);
969 wl_list_insert(below, &surface->layer_link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -0500970 weston_surface_damage_below(surface);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500971 weston_surface_damage(surface);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400972}
973
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400974WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500975weston_compositor_damage_all(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400976{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500977 struct weston_output *output;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400978
979 wl_list_for_each(output, &compositor->output_list, link)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500980 weston_output_damage(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400981}
982
Kristian Høgsberg9f404b72012-01-26 00:11:01 -0500983WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500984weston_buffer_post_release(struct wl_buffer *buffer)
Benjamin Franzke06286262011-05-06 19:12:33 +0200985{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400986 if (--buffer->busy_count > 0)
Benjamin Franzke06286262011-05-06 19:12:33 +0200987 return;
Benjamin Franzke06286262011-05-06 19:12:33 +0200988
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400989 assert(buffer->resource.client != NULL);
Kristian Høgsbergeccef6a2011-11-17 16:46:19 -0500990 wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
Benjamin Franzke06286262011-05-06 19:12:33 +0200991}
992
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400993WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500994weston_output_damage(struct weston_output *output)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400995{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500996 struct weston_compositor *compositor = output->compositor;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400997
Kristian Høgsberg944236a2012-02-28 23:07:47 -0500998 pixman_region32_union(&compositor->damage,
999 &compositor->damage, &output->region);
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001000 weston_output_schedule_repaint(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001001}
1002
Kristian Høgsberg01f941b2009-05-27 17:47:15 -04001003static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001004fade_frame(struct weston_animation *animation,
1005 struct weston_output *output, uint32_t msecs)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001006{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001007 struct weston_compositor *compositor =
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001008 container_of(animation,
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001009 struct weston_compositor, fade.animation);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001010 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001011
Scott Moreau94b0b0c2012-06-14 01:01:56 -06001012 if (animation->frame_counter <= 1)
Scott Moreaue2949db2012-06-11 13:09:23 -06001013 compositor->fade.spring.timestamp = msecs;
1014
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001015 surface = compositor->fade.surface;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001016 weston_spring_update(&compositor->fade.spring, msecs);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001017 weston_surface_set_color(surface, 0.0, 0.0, 0.0,
1018 compositor->fade.spring.current);
1019 weston_surface_damage(surface);
1020
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001021 if (weston_spring_done(&compositor->fade.spring)) {
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001022 compositor->fade.spring.current =
1023 compositor->fade.spring.target;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001024 wl_list_remove(&animation->link);
1025 wl_list_init(&animation->link);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +02001026
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001027 if (compositor->fade.spring.current < 0.001) {
1028 destroy_surface(&surface->surface.resource);
1029 compositor->fade.surface = NULL;
1030 } else if (compositor->fade.spring.current > 0.999) {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001031 compositor->state = WESTON_COMPOSITOR_SLEEPING;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001032 wl_signal_emit(&compositor->lock_signal, compositor);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +02001033 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001034 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001035}
1036
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001037static void
1038update_shm_texture(struct weston_surface *surface)
1039{
1040#ifdef GL_UNPACK_ROW_LENGTH
1041 pixman_box32_t *rectangles;
1042 void *data;
1043 int i, n;
1044#endif
1045
Gwenole Beauchesne023f8552012-04-20 11:07:06 +02001046 glBindTexture(GL_TEXTURE_2D, surface->textures[0]);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001047
1048 if (!surface->compositor->has_unpack_subimage) {
1049 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
1050 surface->pitch, surface->buffer->height, 0,
1051 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1052 wl_shm_buffer_get_data(surface->buffer));
1053
1054 return;
1055 }
1056
1057#ifdef GL_UNPACK_ROW_LENGTH
1058 /* Mesa does not define GL_EXT_unpack_subimage */
1059 glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->pitch);
1060 data = wl_shm_buffer_get_data(surface->buffer);
1061 rectangles = pixman_region32_rectangles(&surface->damage, &n);
1062 for (i = 0; i < n; i++) {
1063 glPixelStorei(GL_UNPACK_SKIP_PIXELS, rectangles[i].x1);
1064 glPixelStorei(GL_UNPACK_SKIP_ROWS, rectangles[i].y1);
1065 glTexSubImage2D(GL_TEXTURE_2D, 0,
1066 rectangles[i].x1, rectangles[i].y1,
Rob Bradford8f241562012-07-02 17:33:40 +01001067 rectangles[i].x2 - rectangles[i].x1,
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001068 rectangles[i].y2 - rectangles[i].y1,
1069 GL_BGRA_EXT, GL_UNSIGNED_BYTE, data);
1070 }
1071#endif
1072}
1073
1074static void
1075surface_accumulate_damage(struct weston_surface *surface,
1076 pixman_region32_t *new_damage,
1077 pixman_region32_t *opaque)
1078{
1079 if (surface->buffer && wl_buffer_is_shm(surface->buffer))
1080 update_shm_texture(surface);
1081
1082 if (surface->transform.enabled) {
1083 pixman_box32_t *extents;
1084
1085 extents = pixman_region32_extents(&surface->damage);
1086 surface_compute_bbox(surface, extents->x1, extents->y1,
1087 extents->x2 - extents->x1,
1088 extents->y2 - extents->y1,
1089 &surface->damage);
1090 } else {
1091 pixman_region32_translate(&surface->damage,
1092 surface->geometry.x,
1093 surface->geometry.y);
1094 }
1095
1096 pixman_region32_subtract(&surface->damage, &surface->damage, opaque);
1097 pixman_region32_union(new_damage, new_damage, &surface->damage);
1098 empty_region(&surface->damage);
1099 pixman_region32_copy(&surface->clip, opaque);
1100 pixman_region32_union(opaque, opaque, &surface->transform.opaque);
1101}
1102
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001103static void
Rob Bradford0fb79752012-08-02 15:36:57 +01001104weston_output_repaint(struct weston_output *output, uint32_t msecs)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001105{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001106 struct weston_compositor *ec = output->compositor;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001107 struct weston_surface *es;
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001108 struct weston_layer *layer;
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001109 struct weston_animation *animation, *next;
1110 struct weston_frame_callback *cb, *cnext;
Jonas Ådahldb773762012-06-13 00:01:21 +02001111 struct wl_list frame_callback_list;
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001112 pixman_region32_t opaque, new_damage, output_damage;
Kristian Høgsberg546a8122012-02-01 07:45:51 -05001113 int32_t width, height;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001114
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001115 weston_compositor_update_drag_surfaces(ec);
1116
Kristian Høgsberg546a8122012-02-01 07:45:51 -05001117 width = output->current->width +
1118 output->border.left + output->border.right;
1119 height = output->current->height +
1120 output->border.top + output->border.bottom;
1121 glViewport(0, 0, width, height);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -05001122
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001123 /* Rebuild the surface list and update surface transforms up front. */
1124 wl_list_init(&ec->surface_list);
Jonas Ådahldb773762012-06-13 00:01:21 +02001125 wl_list_init(&frame_callback_list);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001126 wl_list_for_each(layer, &ec->layer_list, link) {
1127 wl_list_for_each(es, &layer->surface_list, layer_link) {
1128 weston_surface_update_transform(es);
1129 wl_list_insert(ec->surface_list.prev, &es->link);
Jonas Ådahldb773762012-06-13 00:01:21 +02001130 if (es->output == output) {
1131 wl_list_insert_list(&frame_callback_list,
1132 &es->frame_callback_list);
1133 wl_list_init(&es->frame_callback_list);
1134 }
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001135 }
1136 }
Pekka Paalanen15d60ef2012-01-27 14:38:33 +02001137
Jesse Barnes5308a5e2012-02-09 13:12:57 -08001138 if (output->assign_planes)
1139 /*
1140 * This will queue flips for the fbs and sprites where
1141 * applicable and clear the damage for those surfaces.
1142 * The repaint loop below will repaint everything
1143 * else.
1144 */
1145 output->assign_planes(output);
1146
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001147 pixman_region32_init(&new_damage);
1148 pixman_region32_init(&opaque);
1149
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001150 wl_list_for_each(es, &ec->surface_list, link)
1151 surface_accumulate_damage(es, &new_damage, &opaque);
Kristian Høgsberga82c4862012-01-26 01:03:58 -05001152
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001153 pixman_region32_union(&ec->damage, &ec->damage, &new_damage);
1154
1155 pixman_region32_init(&output_damage);
1156 pixman_region32_union(&output_damage,
1157 &ec->damage, &output->previous_damage);
1158 pixman_region32_copy(&output->previous_damage, &ec->damage);
1159 pixman_region32_intersect(&output_damage,
1160 &output_damage, &output->region);
1161 pixman_region32_subtract(&ec->damage, &ec->damage, &output->region);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001162
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -04001163 pixman_region32_fini(&opaque);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -04001164 pixman_region32_fini(&new_damage);
1165
Scott Moreauccbf29d2012-02-22 14:21:41 -07001166 if (output->dirty)
1167 weston_output_update_matrix(output);
1168
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001169 output->repaint(output, &output_damage);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001170
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001171 pixman_region32_fini(&output_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001172
Kristian Høgsbergef044142011-06-21 15:02:12 -04001173 output->repaint_needed = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001174
Kristian Høgsbergaa6019e2012-03-11 16:35:16 -04001175 weston_compositor_repick(ec);
1176 wl_event_loop_dispatch(ec->input_loop, 0);
1177
Jonas Ådahldb773762012-06-13 00:01:21 +02001178 wl_list_for_each_safe(cb, cnext, &frame_callback_list, link) {
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05001179 wl_callback_send_done(&cb->resource, msecs);
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001180 wl_resource_destroy(&cb->resource);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001181 }
Jonas Ådahldb773762012-06-13 00:01:21 +02001182 wl_list_init(&frame_callback_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001183
Scott Moreaud64cf212012-06-08 19:40:54 -06001184 wl_list_for_each_safe(animation, next, &output->animation_list, link) {
Scott Moreaud64cf212012-06-08 19:40:54 -06001185 animation->frame_counter++;
Scott Moreau94b0b0c2012-06-14 01:01:56 -06001186 animation->frame(animation, output, msecs);
Scott Moreaud64cf212012-06-08 19:40:54 -06001187 }
Kristian Høgsbergef044142011-06-21 15:02:12 -04001188}
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001189
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001190static int
1191weston_compositor_read_input(int fd, uint32_t mask, void *data)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001192{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001193 struct weston_compositor *compositor = data;
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05001194
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001195 wl_event_loop_dispatch(compositor->input_loop, 0);
1196
1197 return 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001198}
1199
1200WL_EXPORT void
Rob Bradford0fb79752012-08-02 15:36:57 +01001201weston_output_finish_frame(struct weston_output *output, uint32_t msecs)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001202{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001203 struct weston_compositor *compositor = output->compositor;
1204 struct wl_event_loop *loop =
1205 wl_display_get_event_loop(compositor->wl_display);
1206 int fd;
1207
Kristian Høgsberge9d04922012-06-19 23:54:26 -04001208 output->frame_time = msecs;
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001209 if (output->repaint_needed) {
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001210 weston_output_repaint(output, msecs);
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001211 return;
1212 }
1213
1214 output->repaint_scheduled = 0;
1215 if (compositor->input_loop_source)
1216 return;
1217
1218 fd = wl_event_loop_get_fd(compositor->input_loop);
1219 compositor->input_loop_source =
1220 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
1221 weston_compositor_read_input, compositor);
1222}
1223
1224static void
1225idle_repaint(void *data)
1226{
1227 struct weston_output *output = data;
1228
1229 weston_output_finish_frame(output, weston_compositor_get_time());
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001230}
1231
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001232WL_EXPORT void
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001233weston_layer_init(struct weston_layer *layer, struct wl_list *below)
1234{
1235 wl_list_init(&layer->surface_list);
Jonas Ådahle3cddce2012-06-13 00:01:22 +02001236 if (below != NULL)
1237 wl_list_insert(below, &layer->link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001238}
1239
1240WL_EXPORT void
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001241weston_output_schedule_repaint(struct weston_output *output)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001242{
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001243 struct weston_compositor *compositor = output->compositor;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001244 struct wl_event_loop *loop;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001245
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001246 if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001247 return;
1248
Kristian Høgsbergef044142011-06-21 15:02:12 -04001249 loop = wl_display_get_event_loop(compositor->wl_display);
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001250 output->repaint_needed = 1;
1251 if (output->repaint_scheduled)
1252 return;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001253
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001254 wl_event_loop_add_idle(loop, idle_repaint, output);
1255 output->repaint_scheduled = 1;
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001256
1257 if (compositor->input_loop_source) {
1258 wl_event_source_remove(compositor->input_loop_source);
1259 compositor->input_loop_source = NULL;
1260 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001261}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -05001262
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001263WL_EXPORT void
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001264weston_compositor_schedule_repaint(struct weston_compositor *compositor)
1265{
1266 struct weston_output *output;
1267
1268 wl_list_for_each(output, &compositor->output_list, link)
1269 weston_output_schedule_repaint(output);
1270}
1271
1272WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001273weston_compositor_fade(struct weston_compositor *compositor, float tint)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001274{
Scott Moreau9d1b1122012-06-08 19:40:53 -06001275 struct weston_output *output;
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001276 struct weston_surface *surface;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001277
Scott Moreau9d1b1122012-06-08 19:40:53 -06001278 output = container_of(compositor->output_list.next,
1279 struct weston_output, link);
1280
Kristian Høgsberg269c7822011-05-02 14:38:18 -04001281 compositor->fade.spring.target = tint;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001282 if (weston_spring_done(&compositor->fade.spring))
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001283 return;
1284
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001285 if (compositor->fade.surface == NULL) {
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001286 surface = weston_surface_create(compositor);
1287 weston_surface_configure(surface, 0, 0, 8192, 8192);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001288 weston_surface_set_color(surface, 0.0, 0.0, 0.0, 0.0);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001289 wl_list_insert(&compositor->fade_layer.surface_list,
1290 &surface->layer_link);
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02001291 weston_surface_assign_output(surface);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001292 compositor->fade.surface = surface;
Kristian Høgsberg9bc70952012-02-29 12:22:38 -05001293 pixman_region32_init(&surface->input);
Kristian Høgsberg681f9f42012-01-26 10:55:10 -05001294 }
1295
1296 weston_surface_damage(compositor->fade.surface);
Scott Moreaud64cf212012-06-08 19:40:54 -06001297 if (wl_list_empty(&compositor->fade.animation.link)) {
1298 compositor->fade.animation.frame_counter = 0;
Scott Moreau9d1b1122012-06-08 19:40:53 -06001299 wl_list_insert(output->animation_list.prev,
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001300 &compositor->fade.animation.link);
Scott Moreaud64cf212012-06-08 19:40:54 -06001301 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001302}
1303
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001304static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001305surface_destroy(struct wl_client *client, struct wl_resource *resource)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001306{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001307 wl_resource_destroy(resource);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001308}
1309
Casey Dahlin96d8a752012-04-19 22:50:07 -04001310static struct wl_resource *
1311find_resource_for_client(struct wl_list *list, struct wl_client *client)
1312{
1313 struct wl_resource *r;
1314
1315 wl_list_for_each(r, list, link) {
1316 if (r->client == client)
1317 return r;
1318 }
1319
1320 return NULL;
1321}
1322
Casey Dahlin9074db52012-04-19 22:50:09 -04001323static void
1324weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask)
1325{
1326 uint32_t different = es->output_mask ^ mask;
1327 uint32_t entered = mask & different;
1328 uint32_t left = es->output_mask & different;
1329 struct weston_output *output;
Rob Bradford8667e772012-05-18 14:13:03 +01001330 struct wl_resource *resource = NULL;
Casey Dahlin9074db52012-04-19 22:50:09 -04001331 struct wl_client *client = es->surface.resource.client;
1332
1333 if (es->surface.resource.client == NULL)
1334 return;
1335 if (different == 0)
1336 return;
1337
1338 es->output_mask = mask;
1339 wl_list_for_each(output, &es->compositor->output_list, link) {
1340 if (1 << output->id & different)
1341 resource =
1342 find_resource_for_client(&output->resource_list,
1343 client);
Kristian Høgsbergc7814d22012-07-12 12:34:43 -04001344 if (resource == NULL)
1345 continue;
Casey Dahlin9074db52012-04-19 22:50:09 -04001346 if (1 << output->id & entered)
1347 wl_surface_send_enter(&es->surface.resource, resource);
1348 if (1 << output->id & left)
1349 wl_surface_send_leave(&es->surface.resource, resource);
1350 }
1351}
1352
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001353WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001354weston_surface_assign_output(struct weston_surface *es)
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001355{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001356 struct weston_compositor *ec = es->compositor;
1357 struct weston_output *output, *new_output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001358 pixman_region32_t region;
Casey Dahlin9074db52012-04-19 22:50:09 -04001359 uint32_t max, area, mask;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001360 pixman_box32_t *e;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001361
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001362 new_output = NULL;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001363 max = 0;
Casey Dahlin9074db52012-04-19 22:50:09 -04001364 mask = 0;
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001365 pixman_region32_init(&region);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001366 wl_list_for_each(output, &ec->output_list, link) {
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001367 pixman_region32_intersect(&region, &es->transform.boundingbox,
1368 &output->region);
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001369
1370 e = pixman_region32_extents(&region);
1371 area = (e->x2 - e->x1) * (e->y2 - e->y1);
1372
Casey Dahlin9074db52012-04-19 22:50:09 -04001373 if (area > 0)
1374 mask |= 1 << output->id;
1375
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001376 if (area >= max) {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001377 new_output = output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -07001378 max = area;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001379 }
1380 }
Pekka Paalanen45f3e402012-01-26 11:34:16 +02001381 pixman_region32_fini(&region);
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001382
1383 es->output = new_output;
Casey Dahlin9074db52012-04-19 22:50:09 -04001384 weston_surface_update_output_mask(es, mask);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001385}
1386
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001387static void
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001388surface_attach(struct wl_client *client,
1389 struct wl_resource *resource,
1390 struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
1391{
1392 struct weston_surface *es = resource->data;
1393 struct wl_buffer *buffer = NULL;
1394
1395 if (buffer_resource)
1396 buffer = buffer_resource->data;
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001397
Kristian Høgsberg8cbfb2a2012-03-27 17:04:59 -04001398 weston_surface_attach(&es->surface, buffer);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001399
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03001400 if (buffer && es->configure)
1401 es->configure(es, sx, sy);
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001402}
1403
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001404static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001405surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001406 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001407 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -05001408{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001409 struct weston_surface *es = resource->data;
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -04001410
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001411 pixman_region32_union_rect(&es->damage, &es->damage,
1412 x, y, width, height);
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04001413
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001414 weston_compositor_schedule_repaint(es->compositor);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001415}
1416
Kristian Høgsberg33418202011-08-16 23:01:28 -04001417static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001418destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001419{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001420 struct weston_frame_callback *cb = resource->data;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001421
1422 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02001423 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001424}
1425
1426static void
1427surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001428 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001429{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001430 struct weston_frame_callback *cb;
1431 struct weston_surface *es = resource->data;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001432
1433 cb = malloc(sizeof *cb);
1434 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001435 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001436 return;
1437 }
1438
1439 cb->resource.object.interface = &wl_callback_interface;
1440 cb->resource.object.id = callback;
1441 cb->resource.destroy = destroy_frame_callback;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001442 cb->resource.client = client;
1443 cb->resource.data = cb;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001444
1445 wl_client_add_resource(client, &cb->resource);
Jonas Ådahldb773762012-06-13 00:01:21 +02001446 wl_list_insert(es->frame_callback_list.prev, &cb->link);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001447}
1448
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001449static void
1450surface_set_opaque_region(struct wl_client *client,
1451 struct wl_resource *resource,
1452 struct wl_resource *region_resource)
1453{
1454 struct weston_surface *surface = resource->data;
1455 struct weston_region *region;
1456
1457 pixman_region32_fini(&surface->opaque);
1458
1459 if (region_resource) {
1460 region = region_resource->data;
1461 pixman_region32_init_rect(&surface->opaque, 0, 0,
1462 surface->geometry.width,
1463 surface->geometry.height);
1464 pixman_region32_intersect(&surface->opaque,
1465 &surface->opaque, &region->region);
1466 } else {
1467 pixman_region32_init(&surface->opaque);
1468 }
1469
1470 surface->geometry.dirty = 1;
1471}
1472
1473static void
1474surface_set_input_region(struct wl_client *client,
1475 struct wl_resource *resource,
1476 struct wl_resource *region_resource)
1477{
1478 struct weston_surface *surface = resource->data;
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05001479 struct weston_region *region;
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001480
1481 if (region_resource) {
1482 region = region_resource->data;
1483 pixman_region32_init_rect(&surface->input, 0, 0,
1484 surface->geometry.width,
1485 surface->geometry.height);
1486 pixman_region32_intersect(&surface->input,
1487 &surface->input, &region->region);
1488 } else {
1489 pixman_region32_init_rect(&surface->input, 0, 0,
1490 surface->geometry.width,
1491 surface->geometry.height);
1492 }
1493
Kristian Høgsbergaa6019e2012-03-11 16:35:16 -04001494 weston_compositor_schedule_repaint(surface->compositor);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001495}
1496
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001497static const struct wl_surface_interface surface_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001498 surface_destroy,
1499 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04001500 surface_damage,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001501 surface_frame,
1502 surface_set_opaque_region,
1503 surface_set_input_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001504};
1505
1506static void
1507compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001508 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001509{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001510 struct weston_compositor *ec = resource->data;
1511 struct weston_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001512
Kristian Høgsberg18c93002012-01-27 11:58:31 -05001513 surface = weston_surface_create(ec);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001514 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001515 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001516 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001517 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001518
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001519 surface->surface.resource.destroy = destroy_surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001520
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001521 surface->surface.resource.object.id = id;
1522 surface->surface.resource.object.interface = &wl_surface_interface;
1523 surface->surface.resource.object.implementation =
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001524 (void (**)(void)) &surface_interface;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001525 surface->surface.resource.data = surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001526
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001527 wl_client_add_resource(client, &surface->surface.resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001528}
1529
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001530static void
1531destroy_region(struct wl_resource *resource)
1532{
1533 struct weston_region *region =
1534 container_of(resource, struct weston_region, resource);
1535
1536 pixman_region32_fini(&region->region);
1537 free(region);
1538}
1539
1540static void
1541region_destroy(struct wl_client *client, struct wl_resource *resource)
1542{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001543 wl_resource_destroy(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001544}
1545
1546static void
1547region_add(struct wl_client *client, struct wl_resource *resource,
1548 int32_t x, int32_t y, int32_t width, int32_t height)
1549{
1550 struct weston_region *region = resource->data;
1551
1552 pixman_region32_union_rect(&region->region, &region->region,
1553 x, y, width, height);
1554}
1555
1556static void
1557region_subtract(struct wl_client *client, struct wl_resource *resource,
1558 int32_t x, int32_t y, int32_t width, int32_t height)
1559{
1560 struct weston_region *region = resource->data;
1561 pixman_region32_t rect;
1562
1563 pixman_region32_init_rect(&rect, x, y, width, height);
1564 pixman_region32_subtract(&region->region, &region->region, &rect);
1565 pixman_region32_fini(&rect);
1566}
1567
1568static const struct wl_region_interface region_interface = {
1569 region_destroy,
1570 region_add,
1571 region_subtract
1572};
1573
1574static void
1575compositor_create_region(struct wl_client *client,
1576 struct wl_resource *resource, uint32_t id)
1577{
1578 struct weston_region *region;
1579
1580 region = malloc(sizeof *region);
1581 if (region == NULL) {
1582 wl_resource_post_no_memory(resource);
1583 return;
1584 }
1585
1586 region->resource.destroy = destroy_region;
1587
1588 region->resource.object.id = id;
1589 region->resource.object.interface = &wl_region_interface;
1590 region->resource.object.implementation =
1591 (void (**)(void)) &region_interface;
1592 region->resource.data = region;
1593
1594 pixman_region32_init(&region->region);
1595
1596 wl_client_add_resource(client, &region->resource);
1597}
1598
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04001599static const struct wl_compositor_interface compositor_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001600 compositor_create_surface,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001601 compositor_create_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001602};
1603
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001604WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001605weston_compositor_wake(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001606{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001607 compositor->state = WESTON_COMPOSITOR_ACTIVE;
1608 weston_compositor_fade(compositor, 0.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001609
1610 wl_event_source_timer_update(compositor->idle_source,
Pekka Paalanen7296e792011-12-07 16:22:00 +02001611 compositor->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001612}
1613
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001614static void
1615weston_compositor_dpms_on(struct weston_compositor *compositor)
1616{
1617 struct weston_output *output;
1618
1619 wl_list_for_each(output, &compositor->output_list, link)
1620 if (output->set_dpms)
1621 output->set_dpms(output, WESTON_DPMS_ON);
1622}
1623
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001624WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001625weston_compositor_activity(struct weston_compositor *compositor)
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001626{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001627 if (compositor->state == WESTON_COMPOSITOR_ACTIVE) {
1628 weston_compositor_wake(compositor);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001629 } else {
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02001630 weston_compositor_dpms_on(compositor);
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001631 wl_signal_emit(&compositor->unlock_signal, compositor);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001632 }
1633}
1634
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001635static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001636weston_compositor_idle_inhibit(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001637{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001638 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001639 compositor->idle_inhibit++;
1640}
1641
1642static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001643weston_compositor_idle_release(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001644{
1645 compositor->idle_inhibit--;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001646 weston_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001647}
1648
1649static int
1650idle_handler(void *data)
1651{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001652 struct weston_compositor *compositor = data;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001653
1654 if (compositor->idle_inhibit)
1655 return 1;
1656
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001657 weston_compositor_fade(compositor, 1.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001658
1659 return 1;
1660}
1661
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001662static void
Daniel Stone37816df2012-05-16 18:45:18 +01001663weston_seat_update_drag_surface(struct wl_seat *seat, int dx, int dy);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001664
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001665static void
Daniel Stone37816df2012-05-16 18:45:18 +01001666clip_pointer_motion(struct weston_seat *seat, wl_fixed_t *fx, wl_fixed_t *fy)
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001667{
Daniel Stone37816df2012-05-16 18:45:18 +01001668 struct weston_compositor *ec = seat->compositor;
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001669 struct weston_output *output, *prev = NULL;
1670 int x, y, old_x, old_y, valid = 0;
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001671
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001672 x = wl_fixed_to_int(*fx);
1673 y = wl_fixed_to_int(*fy);
Daniel Stone37816df2012-05-16 18:45:18 +01001674 old_x = wl_fixed_to_int(seat->seat.pointer->x);
1675 old_y = wl_fixed_to_int(seat->seat.pointer->y);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001676
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001677 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001678 if (pixman_region32_contains_point(&output->region,
1679 x, y, NULL))
1680 valid = 1;
1681 if (pixman_region32_contains_point(&output->region,
1682 old_x, old_y, NULL))
1683 prev = output;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001684 }
Daniel Stone37816df2012-05-16 18:45:18 +01001685
Kristian Høgsberg34829de2012-05-09 22:21:14 -04001686 if (!valid) {
1687 if (x < prev->x)
1688 *fx = wl_fixed_from_int(prev->x);
1689 else if (x >= prev->x + prev->current->width)
1690 *fx = wl_fixed_from_int(prev->x +
1691 prev->current->width - 1);
1692 if (y < prev->y)
1693 *fy = wl_fixed_from_int(prev->y);
1694 else if (y >= prev->y + prev->current->height)
1695 *fy = wl_fixed_from_int(prev->y +
1696 prev->current->height - 1);
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001697 }
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001698}
1699
1700WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001701notify_motion(struct wl_seat *seat, uint32_t time, wl_fixed_t x, wl_fixed_t y)
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001702{
1703 const struct wl_pointer_grab_interface *interface;
Daniel Stone37816df2012-05-16 18:45:18 +01001704 struct weston_seat *ws = (struct weston_seat *) seat;
1705 struct weston_compositor *ec = ws->compositor;
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001706 struct weston_output *output;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001707 int32_t ix, iy;
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001708
1709 weston_compositor_activity(ec);
1710
Daniel Stone37816df2012-05-16 18:45:18 +01001711 clip_pointer_motion(ws, &x, &y);
Kristian Høgsberg1f376012012-05-09 11:43:11 -04001712
Daniel Stone37816df2012-05-16 18:45:18 +01001713 weston_seat_update_drag_surface(seat,
1714 x - seat->pointer->x,
1715 y - seat->pointer->y);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001716
Daniel Stone37816df2012-05-16 18:45:18 +01001717 seat->pointer->x = x;
1718 seat->pointer->y = y;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001719
1720 ix = wl_fixed_to_int(x);
1721 iy = wl_fixed_to_int(y);
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -05001722
Scott Moreauccbf29d2012-02-22 14:21:41 -07001723 wl_list_for_each(output, &ec->output_list, link)
1724 if (output->zoom.active &&
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04001725 pixman_region32_contains_point(&output->region,
1726 ix, iy, NULL))
Scott Moreau8dacaab2012-06-17 18:10:58 -06001727 weston_output_update_zoom(output, ZOOM_FOCUS_POINTER);
Scott Moreauccbf29d2012-02-22 14:21:41 -07001728
Daniel Stone37816df2012-05-16 18:45:18 +01001729 weston_device_repick(seat);
1730 interface = seat->pointer->grab->interface;
1731 interface->motion(seat->pointer->grab, time,
1732 seat->pointer->grab->x, seat->pointer->grab->y);
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001733
Daniel Stone37816df2012-05-16 18:45:18 +01001734 if (ws->sprite) {
1735 weston_surface_set_position(ws->sprite,
1736 ix - ws->hotspot_x,
1737 iy - ws->hotspot_y);
Pekka Paalanenf8c6aae2012-02-13 11:01:59 +02001738 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001739 }
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001740}
1741
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001742WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001743weston_surface_activate(struct weston_surface *surface,
Daniel Stone37816df2012-05-16 18:45:18 +01001744 struct weston_seat *seat)
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001745{
Daniel Stone37816df2012-05-16 18:45:18 +01001746 struct weston_compositor *compositor = seat->compositor;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001747
Pekka Paalanenbdc7cd02012-06-07 15:07:07 +03001748 if (seat->seat.keyboard) {
1749 wl_keyboard_set_focus(seat->seat.keyboard, &surface->surface);
1750 wl_data_device_set_keyboard_focus(&seat->seat);
Daniel Stone351eb612012-05-31 15:27:47 -04001751 }
1752
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04001753 wl_signal_emit(&compositor->activate_signal, surface);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001754}
1755
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001756WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001757notify_button(struct wl_seat *seat, uint32_t time, int32_t button,
Daniel Stone4dbadb12012-05-30 16:31:51 +01001758 enum wl_pointer_button_state state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001759{
Daniel Stone37816df2012-05-16 18:45:18 +01001760 struct weston_seat *ws = (struct weston_seat *) seat;
1761 struct weston_compositor *compositor = ws->compositor;
1762 struct weston_surface *focus =
1763 (struct weston_surface *) seat->pointer->focus;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001764 uint32_t serial = wl_display_next_serial(compositor->wl_display);
Kristian Høgsbergea081152010-12-07 08:59:51 -05001765
Daniel Stone4dbadb12012-05-30 16:31:51 +01001766 if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
Scott Moreauff1db4a2012-04-17 19:06:18 -06001767 if (compositor->ping_handler && focus)
1768 compositor->ping_handler(focus, serial);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001769 weston_compositor_idle_inhibit(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001770 if (seat->pointer->button_count == 0) {
1771 seat->pointer->grab_button = button;
1772 seat->pointer->grab_time = time;
1773 seat->pointer->grab_x = seat->pointer->x;
1774 seat->pointer->grab_y = seat->pointer->y;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001775 }
Daniel Stone37816df2012-05-16 18:45:18 +01001776 seat->pointer->button_count++;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001777 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001778 weston_compositor_idle_release(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001779 seat->pointer->button_count--;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001780 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001781
Daniel Stone325fc2d2012-05-30 16:31:58 +01001782 weston_compositor_run_button_binding(compositor, ws, time, button,
1783 state);
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001784
Daniel Stone37816df2012-05-16 18:45:18 +01001785 seat->pointer->grab->interface->button(seat->pointer->grab, time,
1786 button, state);
Kristian Høgsberg5a5f0072011-12-19 14:54:11 -05001787
Daniel Stone37816df2012-05-16 18:45:18 +01001788 if (seat->pointer->button_count == 1)
1789 seat->pointer->grab_serial =
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001790 wl_display_get_serial(compositor->wl_display);
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001791}
1792
Scott Moreau210d0792012-03-22 10:47:01 -06001793WL_EXPORT void
Daniel Stone878f0b72012-05-30 16:31:57 +01001794notify_axis(struct wl_seat *seat, uint32_t time, uint32_t axis,
1795 wl_fixed_t value)
Scott Moreau210d0792012-03-22 10:47:01 -06001796{
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;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001801 uint32_t serial = wl_display_next_serial(compositor->wl_display);
1802
1803 if (compositor->ping_handler && focus)
1804 compositor->ping_handler(focus, serial);
Scott Moreau210d0792012-03-22 10:47:01 -06001805
1806 weston_compositor_activity(compositor);
1807
Scott Moreau6a3633d2012-03-20 08:47:59 -06001808 if (value)
Daniel Stone325fc2d2012-05-30 16:31:58 +01001809 weston_compositor_run_axis_binding(compositor, ws, time, axis,
Daniel Stone0c1e46e2012-05-30 16:31:59 +01001810 value);
Scott Moreau6a3633d2012-03-20 08:47:59 -06001811 else
1812 return;
1813
Daniel Stone37816df2012-05-16 18:45:18 +01001814 if (seat->pointer->focus_resource)
Daniel Stone878f0b72012-05-30 16:31:57 +01001815 wl_pointer_send_axis(seat->pointer->focus_resource, time, axis,
Daniel Stone2fce4022012-05-30 16:32:00 +01001816 value);
Scott Moreau210d0792012-03-22 10:47:01 -06001817}
1818
Daniel Stone05d58682012-06-22 13:21:38 +01001819WL_EXPORT void
1820notify_modifiers(struct wl_seat *wl_seat, uint32_t serial)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001821{
Daniel Stone05d58682012-06-22 13:21:38 +01001822 struct weston_seat *seat = (struct weston_seat *) wl_seat;
1823 struct wl_keyboard *keyboard = &seat->keyboard;
1824 struct wl_keyboard_grab *grab = keyboard->grab;
Daniel Stone7ace3902012-05-30 16:31:40 +01001825 uint32_t mods_depressed, mods_latched, mods_locked, group;
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001826 uint32_t mods_lookup;
Daniel Stone8c8164f2012-05-30 16:31:45 +01001827 enum weston_led leds = 0;
Daniel Stone05d58682012-06-22 13:21:38 +01001828 int changed = 0;
Daniel Stone7ace3902012-05-30 16:31:40 +01001829
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001830 /* Serialize and update our internal state, checking to see if it's
1831 * different to the previous state. */
Daniel Stone994679a2012-05-30 16:31:43 +01001832 mods_depressed = xkb_state_serialize_mods(seat->xkb_state.state,
1833 XKB_STATE_DEPRESSED);
1834 mods_latched = xkb_state_serialize_mods(seat->xkb_state.state,
1835 XKB_STATE_LATCHED);
1836 mods_locked = xkb_state_serialize_mods(seat->xkb_state.state,
1837 XKB_STATE_LOCKED);
1838 group = xkb_state_serialize_group(seat->xkb_state.state,
Daniel Stone7ace3902012-05-30 16:31:40 +01001839 XKB_STATE_EFFECTIVE);
1840
Daniel Stone71c38772012-06-22 13:21:30 +01001841 if (mods_depressed != seat->seat.keyboard->modifiers.mods_depressed ||
1842 mods_latched != seat->seat.keyboard->modifiers.mods_latched ||
1843 mods_locked != seat->seat.keyboard->modifiers.mods_locked ||
1844 group != seat->seat.keyboard->modifiers.group)
Daniel Stone05d58682012-06-22 13:21:38 +01001845 changed = 1;
Daniel Stone7ace3902012-05-30 16:31:40 +01001846
Daniel Stone71c38772012-06-22 13:21:30 +01001847 seat->seat.keyboard->modifiers.mods_depressed = mods_depressed;
1848 seat->seat.keyboard->modifiers.mods_latched = mods_latched;
1849 seat->seat.keyboard->modifiers.mods_locked = mods_locked;
1850 seat->seat.keyboard->modifiers.group = group;
Kristian Høgsbergab909ae2001-01-01 22:24:24 -05001851
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001852 /* And update the modifier_state for bindings. */
1853 mods_lookup = mods_depressed | mods_latched;
1854 seat->modifier_state = 0;
Daniel Stone8db79692012-06-01 12:13:58 +01001855 if (mods_lookup & (1 << seat->xkb_info.ctrl_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001856 seat->modifier_state |= MODIFIER_CTRL;
Daniel Stone8db79692012-06-01 12:13:58 +01001857 if (mods_lookup & (1 << seat->xkb_info.alt_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001858 seat->modifier_state |= MODIFIER_ALT;
Daniel Stone8db79692012-06-01 12:13:58 +01001859 if (mods_lookup & (1 << seat->xkb_info.super_mod))
Daniel Stonee3f15ed2012-05-30 16:31:44 +01001860 seat->modifier_state |= MODIFIER_SUPER;
Kristian Høgsberg73694c82012-06-28 14:13:10 -04001861 if (mods_lookup & (1 << seat->xkb_info.shift_mod))
1862 seat->modifier_state |= MODIFIER_SHIFT;
Daniel Stone7ace3902012-05-30 16:31:40 +01001863
Daniel Stone8c8164f2012-05-30 16:31:45 +01001864 /* Finally, notify the compositor that LEDs have changed. */
1865 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001866 seat->xkb_info.num_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001867 leds |= LED_NUM_LOCK;
1868 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001869 seat->xkb_info.caps_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001870 leds |= LED_CAPS_LOCK;
1871 if (xkb_state_led_index_is_active(seat->xkb_state.state,
Daniel Stoned65b9092012-05-30 16:32:05 +01001872 seat->xkb_info.scroll_led))
Daniel Stone8c8164f2012-05-30 16:31:45 +01001873 leds |= LED_SCROLL_LOCK;
1874 if (leds != seat->xkb_state.leds && seat->led_update)
Daniel Stonebbf63bf2012-06-04 11:40:48 +01001875 seat->led_update(seat, leds);
Daniel Stone8c8164f2012-05-30 16:31:45 +01001876 seat->xkb_state.leds = leds;
1877
Daniel Stone05d58682012-06-22 13:21:38 +01001878 if (changed) {
1879 grab->interface->modifiers(grab,
1880 serial,
1881 keyboard->modifiers.mods_depressed,
1882 keyboard->modifiers.mods_latched,
1883 keyboard->modifiers.mods_locked,
1884 keyboard->modifiers.group);
1885 }
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001886}
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001887
Daniel Stone05d58682012-06-22 13:21:38 +01001888static void
1889update_modifier_state(struct weston_seat *seat, uint32_t serial, uint32_t key,
Daniel Stoned6da09e2012-06-22 13:21:29 +01001890 enum wl_keyboard_key_state state)
1891{
1892 enum xkb_key_direction direction;
1893
1894 if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
1895 direction = XKB_KEY_DOWN;
1896 else
1897 direction = XKB_KEY_UP;
1898
1899 /* Offset the keycode by 8, as the evdev XKB rules reflect X's
1900 * broken keycode system, which starts at 8. */
1901 xkb_state_update_key(seat->xkb_state.state, key + 8, direction);
1902
Daniel Stone05d58682012-06-22 13:21:38 +01001903 notify_modifiers(&seat->seat, serial);
Daniel Stoned6da09e2012-06-22 13:21:29 +01001904}
1905
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001906WL_EXPORT void
Daniel Stonec9785ea2012-05-30 16:31:52 +01001907notify_key(struct wl_seat *seat, uint32_t time, uint32_t key,
Daniel Stone1b4e11f2012-06-22 13:21:37 +01001908 enum wl_keyboard_key_state state,
1909 enum weston_key_state_update update_state)
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001910{
Daniel Stone37816df2012-05-16 18:45:18 +01001911 struct weston_seat *ws = (struct weston_seat *) seat;
1912 struct weston_compositor *compositor = ws->compositor;
1913 struct weston_surface *focus =
Kristian Høgsberg8fe8d242012-06-22 16:57:21 -04001914 (struct weston_surface *) seat->keyboard->focus;
Daniel Stone7ace3902012-05-30 16:31:40 +01001915 struct wl_keyboard_grab *grab = seat->keyboard->grab;
Scott Moreauff1db4a2012-04-17 19:06:18 -06001916 uint32_t serial = wl_display_next_serial(compositor->wl_display);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001917 uint32_t *k, *end;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001918
Daniel Stonec9785ea2012-05-30 16:31:52 +01001919 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
Scott Moreauff1db4a2012-04-17 19:06:18 -06001920 if (compositor->ping_handler && focus)
1921 compositor->ping_handler(focus, serial);
1922
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001923 weston_compositor_idle_inhibit(compositor);
Daniel Stone37816df2012-05-16 18:45:18 +01001924 seat->keyboard->grab_key = key;
1925 seat->keyboard->grab_time = time;
Scott Moreauec286eb2012-02-18 05:05:30 -07001926 } else {
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001927 weston_compositor_idle_release(compositor);
Scott Moreauec286eb2012-02-18 05:05:30 -07001928 }
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001929
Daniel Stone37816df2012-05-16 18:45:18 +01001930 end = seat->keyboard->keys.data + seat->keyboard->keys.size;
1931 for (k = seat->keyboard->keys.data; k < end; k++) {
Daniel Stonec6587ea2012-06-22 13:21:31 +01001932 if (*k == key) {
1933 /* Ignore server-generated repeats. */
1934 if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
1935 return;
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001936 *k = *--end;
Daniel Stonec6587ea2012-06-22 13:21:31 +01001937 }
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001938 }
Daniel Stone37816df2012-05-16 18:45:18 +01001939 seat->keyboard->keys.size = (void *) end - seat->keyboard->keys.data;
Daniel Stonec9785ea2012-05-30 16:31:52 +01001940 if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
Daniel Stone37816df2012-05-16 18:45:18 +01001941 k = wl_array_add(&seat->keyboard->keys, sizeof *k);
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001942 *k = key;
1943 }
Ray Strodee96dcb82008-12-20 02:00:49 -05001944
Scott Moreaubefa6532012-06-11 14:59:31 -06001945 if (grab == &seat->keyboard->default_grab) {
Daniel Stone325fc2d2012-05-30 16:31:58 +01001946 weston_compositor_run_key_binding(compositor, ws, time, key,
1947 state);
Scott Moreaubefa6532012-06-11 14:59:31 -06001948 grab = seat->keyboard->grab;
1949 }
Kristian Høgsbergabcef3c2012-03-05 17:47:15 -05001950
Daniel Stone7ace3902012-05-30 16:31:40 +01001951 grab->interface->key(grab, time, key, state);
Daniel Stone05d58682012-06-22 13:21:38 +01001952
1953 if (update_state == STATE_UPDATE_AUTOMATIC) {
1954 update_modifier_state(ws,
1955 wl_display_get_serial(compositor->wl_display),
1956 key,
1957 state);
1958 }
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001959}
1960
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001961WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01001962notify_pointer_focus(struct wl_seat *seat, struct weston_output *output,
1963 wl_fixed_t x, wl_fixed_t y)
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001964{
Daniel Stone37816df2012-05-16 18:45:18 +01001965 struct weston_seat *ws = (struct weston_seat *) seat;
1966 struct weston_compositor *compositor = ws->compositor;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001967
1968 if (output) {
Daniel Stone37816df2012-05-16 18:45:18 +01001969 weston_seat_update_drag_surface(seat,
1970 x - seat->pointer->x,
1971 y - seat->pointer->y);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02001972
Daniel Stone37816df2012-05-16 18:45:18 +01001973 seat->pointer->x = x;
1974 seat->pointer->y = y;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001975 compositor->focus = 1;
Kristian Høgsberg9ddb8262012-01-04 21:30:29 -05001976 weston_compositor_repick(compositor);
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001977 } else {
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001978 compositor->focus = 0;
Tiago Vignatticd717b52012-07-12 00:46:10 +03001979 /* FIXME: We should call wl_pointer_set_focus(seat,
1980 * NULL) here, but somehow that breaks re-entry... */
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001981 }
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001982}
1983
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001984static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04001985destroy_device_saved_kbd_focus(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001986{
Daniel Stone37816df2012-05-16 18:45:18 +01001987 struct weston_seat *ws;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001988
Daniel Stone37816df2012-05-16 18:45:18 +01001989 ws = container_of(listener, struct weston_seat,
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001990 saved_kbd_focus_listener);
1991
Daniel Stone37816df2012-05-16 18:45:18 +01001992 ws->saved_kbd_focus = NULL;
Ander Conselvan de Oliveira71b1d0c2012-03-16 17:25:11 +02001993}
1994
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001995WL_EXPORT void
Daniel Stoned6da09e2012-06-22 13:21:29 +01001996notify_keyboard_focus_in(struct wl_seat *seat, struct wl_array *keys,
1997 enum weston_key_state_update update_state)
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001998{
Daniel Stone37816df2012-05-16 18:45:18 +01001999 struct weston_seat *ws = (struct weston_seat *) seat;
2000 struct weston_compositor *compositor = ws->compositor;
Kristian Høgsbergafee2212012-03-20 17:28:20 -04002001 struct wl_surface *surface;
Kristian Høgsbergc7cd6262012-06-28 13:46:09 -04002002 uint32_t *k, serial;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05002003
Kristian Høgsbergc7cd6262012-06-28 13:46:09 -04002004 serial = wl_display_next_serial(compositor->wl_display);
Daniel Stoned6da09e2012-06-22 13:21:29 +01002005 wl_array_copy(&seat->keyboard->keys, keys);
2006 wl_array_for_each(k, &seat->keyboard->keys) {
2007 weston_compositor_idle_inhibit(compositor);
2008 if (update_state == STATE_UPDATE_AUTOMATIC)
Kristian Høgsbergc7cd6262012-06-28 13:46:09 -04002009 update_modifier_state(ws, serial, *k,
Daniel Stoned6da09e2012-06-22 13:21:29 +01002010 WL_KEYBOARD_KEY_STATE_PRESSED);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05002011 }
Daniel Stoned6da09e2012-06-22 13:21:29 +01002012
Daniel Stoneef172672012-06-22 13:21:32 +01002013 /* Run key bindings after we've updated the state. */
2014 wl_array_for_each(k, &seat->keyboard->keys) {
2015 weston_compositor_run_key_binding(compositor, ws, 0, *k,
2016 WL_KEYBOARD_KEY_STATE_PRESSED);
2017 }
2018
Daniel Stoned6da09e2012-06-22 13:21:29 +01002019 surface = ws->saved_kbd_focus;
2020
2021 if (surface) {
2022 wl_list_remove(&ws->saved_kbd_focus_listener.link);
2023 wl_keyboard_set_focus(ws->seat.keyboard, surface);
Daniel Stoned6da09e2012-06-22 13:21:29 +01002024 ws->saved_kbd_focus = NULL;
2025 }
2026}
2027
2028WL_EXPORT void
2029notify_keyboard_focus_out(struct wl_seat *seat)
2030{
2031 struct weston_seat *ws = (struct weston_seat *) seat;
2032 struct weston_compositor *compositor = ws->compositor;
2033 struct wl_surface *surface;
Kristian Høgsbergc7cd6262012-06-28 13:46:09 -04002034 uint32_t *k, serial;
Daniel Stoned6da09e2012-06-22 13:21:29 +01002035
Kristian Høgsbergc7cd6262012-06-28 13:46:09 -04002036 serial = wl_display_next_serial(compositor->wl_display);
2037 wl_array_for_each(k, &seat->keyboard->keys) {
Daniel Stoned6da09e2012-06-22 13:21:29 +01002038 weston_compositor_idle_release(compositor);
Kristian Høgsbergc7cd6262012-06-28 13:46:09 -04002039 update_modifier_state(ws, serial, *k,
2040 WL_KEYBOARD_KEY_STATE_RELEASED);
2041 }
Daniel Stoned6da09e2012-06-22 13:21:29 +01002042
2043 ws->modifier_state = 0;
2044
2045 surface = ws->seat.keyboard->focus;
2046
2047 if (surface) {
2048 ws->saved_kbd_focus = surface;
2049 ws->saved_kbd_focus_listener.notify =
2050 destroy_device_saved_kbd_focus;
2051 wl_signal_add(&surface->resource.destroy_signal,
2052 &ws->saved_kbd_focus_listener);
2053 }
2054
2055 wl_keyboard_set_focus(ws->seat.keyboard, NULL);
2056 /* FIXME: We really need keyboard grab cancel here to
2057 * let the grab shut down properly. As it is we leak
2058 * the grab data. */
2059 wl_keyboard_end_grab(ws->seat.keyboard);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05002060}
2061
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002062static void
Daniel Stone37816df2012-05-16 18:45:18 +01002063touch_set_focus(struct weston_seat *ws, struct wl_surface *surface)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002064{
Daniel Stone37816df2012-05-16 18:45:18 +01002065 struct wl_seat *seat = &ws->seat;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002066 struct wl_resource *resource;
2067
Pekka Paalanen56464252012-07-31 13:21:08 +03002068 if (seat->touch->focus == surface)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002069 return;
2070
Pekka Paalanen56464252012-07-31 13:21:08 +03002071 if (seat->touch->focus_resource)
2072 wl_list_remove(&seat->touch->focus_listener.link);
2073 seat->touch->focus = NULL;
2074 seat->touch->focus_resource = NULL;
2075
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002076 if (surface) {
2077 resource =
Daniel Stone37816df2012-05-16 18:45:18 +01002078 find_resource_for_client(&seat->touch->resource_list,
Casey Dahlin96d8a752012-04-19 22:50:07 -04002079 surface->resource.client);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002080 if (!resource) {
Martin Minarik6d118362012-06-07 18:01:59 +02002081 weston_log("couldn't find resource\n");
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002082 return;
2083 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002084
Daniel Stone37816df2012-05-16 18:45:18 +01002085 seat->touch->focus = surface;
2086 seat->touch->focus_resource = resource;
Pekka Paalanen56464252012-07-31 13:21:08 +03002087 wl_signal_add(&resource->destroy_signal,
2088 &seat->touch->focus_listener);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002089 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002090}
2091
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002092/**
2093 * notify_touch - emulates button touches and notifies surfaces accordingly.
2094 *
2095 * It assumes always the correct cycle sequence until it gets here: touch_down
2096 * → touch_update → ... → touch_update → touch_end. The driver is responsible
2097 * for sending along such order.
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002098 *
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002099 */
2100WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01002101notify_touch(struct wl_seat *seat, uint32_t time, int touch_id,
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002102 wl_fixed_t x, wl_fixed_t y, int touch_type)
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002103{
Daniel Stone37816df2012-05-16 18:45:18 +01002104 struct weston_seat *ws = (struct weston_seat *) seat;
2105 struct weston_compositor *ec = ws->compositor;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002106 struct weston_surface *es;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002107 wl_fixed_t sx, sy;
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04002108 uint32_t serial = 0;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002109
2110 switch (touch_type) {
Daniel Stone37816df2012-05-16 18:45:18 +01002111 case WL_TOUCH_DOWN:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002112 weston_compositor_idle_inhibit(ec);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002113
Daniel Stone37816df2012-05-16 18:45:18 +01002114 ws->num_tp++;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002115
2116 /* the first finger down picks the surface, and all further go
2117 * to that surface for the remainder of the touch session i.e.
2118 * until all touch points are up again. */
Daniel Stone37816df2012-05-16 18:45:18 +01002119 if (ws->num_tp == 1) {
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002120 es = weston_compositor_pick_surface(ec, x, y, &sx, &sy);
Daniel Stone37816df2012-05-16 18:45:18 +01002121 touch_set_focus(ws, &es->surface);
Pekka Paalanen56464252012-07-31 13:21:08 +03002122 } else if (seat->touch->focus) {
2123 es = (struct weston_surface *)seat->touch->focus;
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002124 weston_surface_from_global_fixed(es, x, y, &sx, &sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002125 }
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002126
Pekka Paalanen56464252012-07-31 13:21:08 +03002127 if (seat->touch->focus_resource && seat->touch->focus)
2128 wl_touch_send_down(seat->touch->focus_resource,
Daniel Stone37816df2012-05-16 18:45:18 +01002129 serial, time,
Pekka Paalanen56464252012-07-31 13:21:08 +03002130 &seat->touch->focus->resource,
Daniel Stone37816df2012-05-16 18:45:18 +01002131 touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002132 break;
Daniel Stone37816df2012-05-16 18:45:18 +01002133 case WL_TOUCH_MOTION:
Pekka Paalanen56464252012-07-31 13:21:08 +03002134 es = (struct weston_surface *)seat->touch->focus;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05002135 if (!es)
2136 break;
2137
Kristian Høgsberge11bbe42012-05-09 12:19:04 -04002138 weston_surface_from_global_fixed(es, x, y, &sx, &sy);
Pekka Paalanen56464252012-07-31 13:21:08 +03002139 if (seat->touch->focus_resource)
2140 wl_touch_send_motion(seat->touch->focus_resource,
Daniel Stone37816df2012-05-16 18:45:18 +01002141 time, touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002142 break;
Daniel Stone37816df2012-05-16 18:45:18 +01002143 case WL_TOUCH_UP:
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002144 weston_compositor_idle_release(ec);
Daniel Stone37816df2012-05-16 18:45:18 +01002145 ws->num_tp--;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002146
Pekka Paalanen56464252012-07-31 13:21:08 +03002147 if (seat->touch->focus_resource)
2148 wl_touch_send_up(seat->touch->focus_resource,
Daniel Stone37816df2012-05-16 18:45:18 +01002149 serial, time, touch_id);
2150 if (ws->num_tp == 0)
2151 touch_set_focus(ws, NULL);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02002152 break;
2153 }
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02002154}
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05002155
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04002156static void
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002157pointer_handle_sprite_destroy(struct wl_listener *listener, void *data)
2158{
2159 struct weston_seat *seat = container_of(listener, struct weston_seat,
2160 sprite_destroy_listener);
2161
2162 seat->sprite = NULL;
2163}
2164
2165static void
2166pointer_cursor_surface_configure(struct weston_surface *es,
2167 int32_t dx, int32_t dy)
2168{
2169 struct weston_seat *seat = es->private;
2170 int x, y;
2171
2172 assert(es == seat->sprite);
2173
2174 seat->hotspot_x -= dx;
2175 seat->hotspot_y -= dy;
2176
2177 x = wl_fixed_to_int(seat->seat.pointer->x) - seat->hotspot_x;
2178 y = wl_fixed_to_int(seat->seat.pointer->y) - seat->hotspot_y;
2179
2180 weston_surface_configure(seat->sprite, x, y,
2181 es->buffer->width, es->buffer->height);
2182
Ander Conselvan de Oliveiraf1c00c02012-07-04 15:48:29 +03002183 empty_region(&es->input);
2184
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002185 if (!weston_surface_is_mapped(es)) {
2186 wl_list_insert(&es->compositor->cursor_layer.surface_list,
2187 &es->layer_link);
2188 weston_surface_assign_output(es);
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002189 }
2190}
2191
2192static void
2193pointer_unmap_sprite(struct weston_seat *seat)
2194{
2195 if (weston_surface_is_mapped(seat->sprite))
2196 weston_surface_unmap(seat->sprite);
2197
2198 wl_list_remove(&seat->sprite_destroy_listener.link);
2199 seat->sprite->configure = NULL;
2200 seat->sprite->private = NULL;
2201 seat->sprite = NULL;
2202}
2203
2204static void
2205pointer_set_cursor(struct wl_client *client, struct wl_resource *resource,
2206 uint32_t serial, struct wl_resource *surface_resource,
2207 int32_t x, int32_t y)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002208{
Daniel Stone37816df2012-05-16 18:45:18 +01002209 struct weston_seat *seat = resource->data;
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002210 struct weston_surface *surface = NULL;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002211
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002212 if (surface_resource)
2213 surface = container_of(surface_resource->data,
2214 struct weston_surface, surface);
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04002215
Kristian Høgsberg649e1ce2012-08-01 09:46:12 -04002216 if (seat->seat.pointer->focus == NULL)
2217 return;
2218 if (seat->seat.pointer->focus->resource.client != client)
2219 return;
Kristian Høgsberg2e96d3c2012-08-01 09:39:11 -04002220 if (seat->seat.pointer->focus_serial - serial > UINT32_MAX / 2)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002221 return;
Ander Conselvan de Oliveira1fbda0e2012-06-28 18:08:04 +03002222
2223 if (surface && surface != seat->sprite) {
Ander Conselvan de Oliveira1fbda0e2012-06-28 18:08:04 +03002224 if (surface->configure) {
2225 wl_resource_post_error(&surface->surface.resource,
2226 WL_DISPLAY_ERROR_INVALID_OBJECT,
2227 "surface->configure already "
2228 "set");
2229 return;
2230 }
Pekka Paalanenf07cb5d2012-02-10 13:34:36 +02002231 }
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05002232
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002233 if (seat->sprite)
2234 pointer_unmap_sprite(seat);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03002235
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002236 if (!surface)
2237 return;
2238
2239 wl_signal_add(&surface->surface.resource.destroy_signal,
2240 &seat->sprite_destroy_listener);
2241
2242 surface->configure = pointer_cursor_surface_configure;
2243 surface->private = seat;
2244 empty_region(&surface->input);
2245
2246 seat->sprite = surface;
Daniel Stone37816df2012-05-16 18:45:18 +01002247 seat->hotspot_x = x;
2248 seat->hotspot_y = y;
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05002249
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002250 weston_surface_set_position(surface,
2251 wl_fixed_to_int(seat->seat.pointer->x) - x,
2252 wl_fixed_to_int(seat->seat.pointer->y) - y);
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002253}
2254
Daniel Stone37816df2012-05-16 18:45:18 +01002255static const struct wl_pointer_interface pointer_interface = {
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002256 pointer_set_cursor
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05002257};
2258
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002259static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002260handle_drag_surface_destroy(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002261{
Daniel Stone37816df2012-05-16 18:45:18 +01002262 struct weston_seat *seat;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002263
Daniel Stone37816df2012-05-16 18:45:18 +01002264 seat = container_of(listener, struct weston_seat,
2265 drag_surface_destroy_listener);
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002266
Daniel Stone37816df2012-05-16 18:45:18 +01002267 seat->drag_surface = NULL;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002268}
2269
Casey Dahlin9074db52012-04-19 22:50:09 -04002270static void unbind_resource(struct wl_resource *resource)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04002271{
2272 wl_list_remove(&resource->link);
2273 free(resource);
2274}
2275
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002276static void
Daniel Stone37816df2012-05-16 18:45:18 +01002277seat_get_pointer(struct wl_client *client, struct wl_resource *resource,
2278 uint32_t id)
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002279{
Daniel Stone37816df2012-05-16 18:45:18 +01002280 struct weston_seat *seat = resource->data;
2281 struct wl_resource *cr;
Kristian Høgsberg8e6d7122011-08-29 16:04:39 -04002282
Daniel Stone37816df2012-05-16 18:45:18 +01002283 if (!seat->seat.pointer)
2284 return;
2285
2286 cr = wl_client_add_object(client, &wl_pointer_interface,
2287 &pointer_interface, id, seat);
2288 wl_list_insert(&seat->seat.pointer->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002289 cr->destroy = unbind_resource;
Daniel Stone17b13bd2012-05-30 16:31:39 +01002290
2291 if (seat->seat.pointer->focus &&
2292 seat->seat.pointer->focus->resource.client == client) {
2293 struct weston_surface *surface;
2294 wl_fixed_t sx, sy;
2295
2296 surface = (struct weston_surface *) seat->seat.pointer->focus;
2297 weston_surface_from_global_fixed(surface,
2298 seat->seat.pointer->x,
2299 seat->seat.pointer->y,
2300 &sx,
2301 &sy);
2302 wl_pointer_set_focus(seat->seat.pointer,
2303 seat->seat.pointer->focus,
2304 sx,
2305 sy);
2306 }
Daniel Stone37816df2012-05-16 18:45:18 +01002307}
2308
2309static void
2310seat_get_keyboard(struct wl_client *client, struct wl_resource *resource,
2311 uint32_t id)
2312{
2313 struct weston_seat *seat = resource->data;
2314 struct wl_resource *cr;
2315
2316 if (!seat->seat.keyboard)
2317 return;
2318
2319 cr = wl_client_add_object(client, &wl_keyboard_interface, NULL, id,
2320 seat);
2321 wl_list_insert(&seat->seat.keyboard->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002322 cr->destroy = unbind_resource;
Daniel Stone17b13bd2012-05-30 16:31:39 +01002323
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002324 wl_keyboard_send_keymap(cr, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
2325 seat->xkb_info.keymap_fd,
2326 seat->xkb_info.keymap_size);
2327
Daniel Stone17b13bd2012-05-30 16:31:39 +01002328 if (seat->seat.keyboard->focus &&
2329 seat->seat.keyboard->focus->resource.client == client) {
2330 wl_keyboard_set_focus(seat->seat.keyboard,
2331 seat->seat.keyboard->focus);
2332 }
Daniel Stone37816df2012-05-16 18:45:18 +01002333}
2334
2335static void
2336seat_get_touch(struct wl_client *client, struct wl_resource *resource,
2337 uint32_t id)
2338{
2339 struct weston_seat *seat = resource->data;
2340 struct wl_resource *cr;
2341
2342 if (!seat->seat.touch)
2343 return;
2344
2345 cr = wl_client_add_object(client, &wl_touch_interface, NULL, id, seat);
2346 wl_list_insert(&seat->seat.touch->resource_list, &cr->link);
Kristian Høgsbergb93b6cf2012-05-16 22:32:40 -04002347 cr->destroy = unbind_resource;
Daniel Stone37816df2012-05-16 18:45:18 +01002348}
2349
2350static const struct wl_seat_interface seat_interface = {
2351 seat_get_pointer,
2352 seat_get_keyboard,
2353 seat_get_touch,
2354};
2355
2356static void
2357bind_seat(struct wl_client *client, void *data, uint32_t version, uint32_t id)
2358{
2359 struct wl_seat *seat = data;
2360 struct wl_resource *resource;
2361 enum wl_seat_capability caps = 0;
2362
2363 resource = wl_client_add_object(client, &wl_seat_interface,
2364 &seat_interface, id, data);
2365 wl_list_insert(&seat->base_resource_list, &resource->link);
Casey Dahlin9074db52012-04-19 22:50:09 -04002366 resource->destroy = unbind_resource;
Daniel Stone37816df2012-05-16 18:45:18 +01002367
2368 if (seat->pointer)
2369 caps |= WL_SEAT_CAPABILITY_POINTER;
2370 if (seat->keyboard)
2371 caps |= WL_SEAT_CAPABILITY_KEYBOARD;
2372 if (seat->touch)
2373 caps |= WL_SEAT_CAPABILITY_TOUCH;
2374
2375 wl_seat_send_capabilities(resource, caps);
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002376}
2377
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002378static void
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002379device_handle_new_drag_icon(struct wl_listener *listener, void *data)
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002380{
Daniel Stone37816df2012-05-16 18:45:18 +01002381 struct weston_seat *seat;
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002382
Daniel Stone37816df2012-05-16 18:45:18 +01002383 seat = container_of(listener, struct weston_seat,
2384 new_drag_icon_listener);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002385
Daniel Stone37816df2012-05-16 18:45:18 +01002386 weston_seat_update_drag_surface(&seat->seat, 0, 0);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002387}
2388
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002389static void weston_compositor_xkb_init(struct weston_compositor *ec,
2390 struct xkb_rule_names *names)
Daniel Stone994679a2012-05-30 16:31:43 +01002391{
Daniel Stonee379da92012-05-30 16:32:04 +01002392 if (ec->xkb_context == NULL) {
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002393 ec->xkb_context = xkb_context_new(0);
2394 if (ec->xkb_context == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002395 weston_log("failed to create XKB context\n");
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002396 exit(1);
2397 }
Daniel Stone994679a2012-05-30 16:31:43 +01002398 }
2399
2400 if (names)
Daniel Stonee379da92012-05-30 16:32:04 +01002401 ec->xkb_names = *names;
2402 if (!ec->xkb_names.rules)
2403 ec->xkb_names.rules = strdup("evdev");
2404 if (!ec->xkb_names.model)
2405 ec->xkb_names.model = strdup("pc105");
2406 if (!ec->xkb_names.layout)
2407 ec->xkb_names.layout = strdup("us");
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002408}
2409
Daniel Stonee379da92012-05-30 16:32:04 +01002410static void xkb_info_destroy(struct weston_xkb_info *xkb_info)
2411{
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002412 if (xkb_info->keymap)
2413 xkb_map_unref(xkb_info->keymap);
2414
2415 if (xkb_info->keymap_area)
2416 munmap(xkb_info->keymap_area, xkb_info->keymap_size);
2417 if (xkb_info->keymap_fd >= 0)
2418 close(xkb_info->keymap_fd);
Daniel Stonee379da92012-05-30 16:32:04 +01002419}
2420
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002421static void weston_compositor_xkb_destroy(struct weston_compositor *ec)
2422{
Daniel Stonee379da92012-05-30 16:32:04 +01002423 free((char *) ec->xkb_names.rules);
2424 free((char *) ec->xkb_names.model);
2425 free((char *) ec->xkb_names.layout);
2426 free((char *) ec->xkb_names.variant);
2427 free((char *) ec->xkb_names.options);
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002428
Daniel Stonee379da92012-05-30 16:32:04 +01002429 xkb_info_destroy(&ec->xkb_info);
2430 xkb_context_unref(ec->xkb_context);
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002431}
2432
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002433static void
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002434weston_xkb_info_new_keymap(struct weston_xkb_info *xkb_info)
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002435{
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002436 char *keymap_str;
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002437
Daniel Stoneabb9dcd2012-06-22 13:21:33 +01002438 xkb_info->shift_mod = xkb_map_mod_get_index(xkb_info->keymap,
2439 XKB_MOD_NAME_SHIFT);
2440 xkb_info->caps_mod = xkb_map_mod_get_index(xkb_info->keymap,
2441 XKB_MOD_NAME_CAPS);
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002442 xkb_info->ctrl_mod = xkb_map_mod_get_index(xkb_info->keymap,
2443 XKB_MOD_NAME_CTRL);
2444 xkb_info->alt_mod = xkb_map_mod_get_index(xkb_info->keymap,
2445 XKB_MOD_NAME_ALT);
Daniel Stoneabb9dcd2012-06-22 13:21:33 +01002446 xkb_info->mod2_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod2");
2447 xkb_info->mod3_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod3");
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002448 xkb_info->super_mod = xkb_map_mod_get_index(xkb_info->keymap,
2449 XKB_MOD_NAME_LOGO);
Daniel Stoneabb9dcd2012-06-22 13:21:33 +01002450 xkb_info->mod5_mod = xkb_map_mod_get_index(xkb_info->keymap, "Mod5");
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002451
2452 xkb_info->num_led = xkb_map_led_get_index(xkb_info->keymap,
2453 XKB_LED_NAME_NUM);
2454 xkb_info->caps_led = xkb_map_led_get_index(xkb_info->keymap,
2455 XKB_LED_NAME_CAPS);
2456 xkb_info->scroll_led = xkb_map_led_get_index(xkb_info->keymap,
2457 XKB_LED_NAME_SCROLL);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002458
2459 keymap_str = xkb_map_get_as_string(xkb_info->keymap);
2460 if (keymap_str == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002461 weston_log("failed to get string version of keymap\n");
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002462 exit(EXIT_FAILURE);
2463 }
2464 xkb_info->keymap_size = strlen(keymap_str) + 1;
2465
Pekka Paalanen1da1b8f2012-06-06 16:59:43 +03002466 xkb_info->keymap_fd = os_create_anonymous_file(xkb_info->keymap_size);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002467 if (xkb_info->keymap_fd < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +02002468 weston_log("creating a keymap file for %lu bytes failed: %m\n",
Pekka Paalanen1da1b8f2012-06-06 16:59:43 +03002469 (unsigned long) xkb_info->keymap_size);
2470 goto err_keymap_str;
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002471 }
2472
2473 xkb_info->keymap_area = mmap(NULL, xkb_info->keymap_size,
2474 PROT_READ | PROT_WRITE,
2475 MAP_SHARED, xkb_info->keymap_fd, 0);
2476 if (xkb_info->keymap_area == MAP_FAILED) {
Martin Minarik6d118362012-06-07 18:01:59 +02002477 weston_log("failed to mmap() %lu bytes\n",
Pekka Paalanen1da1b8f2012-06-06 16:59:43 +03002478 (unsigned long) xkb_info->keymap_size);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002479 goto err_dev_zero;
2480 }
2481 strcpy(xkb_info->keymap_area, keymap_str);
2482 free(keymap_str);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002483
2484 return;
2485
2486err_dev_zero:
2487 close(xkb_info->keymap_fd);
2488 xkb_info->keymap_fd = -1;
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002489err_keymap_str:
2490 free(keymap_str);
2491 exit(EXIT_FAILURE);
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002492}
2493
2494static void
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002495weston_compositor_build_global_keymap(struct weston_compositor *ec)
2496{
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002497 if (ec->xkb_info.keymap != NULL)
2498 return;
2499
Daniel Stonee379da92012-05-30 16:32:04 +01002500 ec->xkb_info.keymap = xkb_map_new_from_names(ec->xkb_context,
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002501 &ec->xkb_names,
2502 0);
Daniel Stone994679a2012-05-30 16:31:43 +01002503 if (ec->xkb_info.keymap == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002504 weston_log("failed to compile global XKB keymap\n");
2505 weston_log(" tried rules %s, model %s, layout %s, variant %s, "
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002506 "options %s",
2507 ec->xkb_names.rules, ec->xkb_names.model,
2508 ec->xkb_names.layout, ec->xkb_names.variant,
2509 ec->xkb_names.options);
2510 exit(1);
Daniel Stone994679a2012-05-30 16:31:43 +01002511 }
2512
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002513 weston_xkb_info_new_keymap(&ec->xkb_info);
Daniel Stone994679a2012-05-30 16:31:43 +01002514}
2515
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002516WL_EXPORT void
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002517weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap)
Daniel Stone994679a2012-05-30 16:31:43 +01002518{
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002519 if (seat->has_keyboard)
2520 return;
Daniel Stone994679a2012-05-30 16:31:43 +01002521
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002522 if (keymap != NULL) {
2523 seat->xkb_info.keymap = xkb_map_ref(keymap);
Daniel Stoneb7452fe2012-06-01 12:14:06 +01002524 weston_xkb_info_new_keymap(&seat->xkb_info);
Daniel Stonebb1df6a2012-05-30 16:32:06 +01002525 }
2526 else {
2527 weston_compositor_build_global_keymap(seat->compositor);
2528 seat->xkb_info = seat->compositor->xkb_info;
2529 seat->xkb_info.keymap = xkb_map_ref(seat->xkb_info.keymap);
2530 }
Daniel Stoned65b9092012-05-30 16:32:05 +01002531
2532 seat->xkb_state.state = xkb_state_new(seat->xkb_info.keymap);
2533 if (seat->xkb_state.state == NULL) {
Martin Minarik6d118362012-06-07 18:01:59 +02002534 weston_log("failed to initialise XKB state\n");
Daniel Stoned65b9092012-05-30 16:32:05 +01002535 exit(1);
2536 }
2537
Daniel Stone71c38772012-06-22 13:21:30 +01002538 seat->xkb_state.leds = 0;
Daniel Stoned65b9092012-05-30 16:32:05 +01002539
Daniel Stone9a9ee2c2012-05-30 16:32:03 +01002540 wl_keyboard_init(&seat->keyboard);
2541 wl_seat_set_keyboard(&seat->seat, &seat->keyboard);
2542
2543 seat->has_keyboard = 1;
Daniel Stone994679a2012-05-30 16:31:43 +01002544}
2545
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002546WL_EXPORT void
Daniel Stone74419a22012-05-30 16:32:02 +01002547weston_seat_init_pointer(struct weston_seat *seat)
2548{
2549 if (seat->has_pointer)
2550 return;
2551
2552 wl_pointer_init(&seat->pointer);
2553 wl_seat_set_pointer(&seat->seat, &seat->pointer);
2554
2555 seat->has_pointer = 1;
2556}
2557
2558WL_EXPORT void
Daniel Stone74419a22012-05-30 16:32:02 +01002559weston_seat_init_touch(struct weston_seat *seat)
2560{
2561 if (seat->has_touch)
2562 return;
2563
2564 wl_touch_init(&seat->touch);
2565 wl_seat_set_touch(&seat->seat, &seat->touch);
2566
2567 seat->has_touch = 1;
2568}
2569
2570WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01002571weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05002572{
Daniel Stone37816df2012-05-16 18:45:18 +01002573 wl_seat_init(&seat->seat);
Daniel Stone74419a22012-05-30 16:32:02 +01002574 seat->has_pointer = 0;
2575 seat->has_keyboard = 0;
2576 seat->has_touch = 0;
Kristian Høgsberg02ef1c12010-12-06 21:35:19 -05002577
Daniel Stone37816df2012-05-16 18:45:18 +01002578 wl_display_add_global(ec->wl_display, &wl_seat_interface, seat,
2579 bind_seat);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04002580
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002581 seat->sprite = NULL;
2582 seat->sprite_destroy_listener.notify = pointer_handle_sprite_destroy;
Kristian Høgsberg8244b442011-06-23 15:44:14 -04002583
Daniel Stone37816df2012-05-16 18:45:18 +01002584 seat->compositor = ec;
2585 seat->hotspot_x = 16;
2586 seat->hotspot_y = 16;
2587 seat->modifier_state = 0;
2588 seat->num_tp = 0;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05002589
Daniel Stone37816df2012-05-16 18:45:18 +01002590 seat->drag_surface_destroy_listener.notify =
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002591 handle_drag_surface_destroy;
Ander Conselvan de Oliveirac5fb9a72012-03-01 14:09:44 +02002592
Daniel Stone37816df2012-05-16 18:45:18 +01002593 wl_list_insert(ec->seat_list.prev, &seat->link);
Ander Conselvan de Oliveirad6ea33d2012-03-27 17:36:39 +03002594
Daniel Stone37816df2012-05-16 18:45:18 +01002595 seat->new_drag_icon_listener.notify = device_handle_new_drag_icon;
2596 wl_signal_add(&seat->seat.drag_icon_signal,
2597 &seat->new_drag_icon_listener);
Kristian Høgsberga7ceaff2012-06-03 10:20:13 -04002598
2599 clipboard_create(seat);
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05002600}
2601
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002602WL_EXPORT void
Daniel Stone37816df2012-05-16 18:45:18 +01002603weston_seat_release(struct weston_seat *seat)
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002604{
Daniel Stone37816df2012-05-16 18:45:18 +01002605 wl_list_remove(&seat->link);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002606 /* The global object is destroyed at wl_display_destroy() time. */
2607
Daniel Stone37816df2012-05-16 18:45:18 +01002608 if (seat->sprite)
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002609 pointer_unmap_sprite(seat);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002610
Daniel Stone74419a22012-05-30 16:32:02 +01002611 if (seat->xkb_state.state != NULL)
2612 xkb_state_unref(seat->xkb_state.state);
Daniel Stoned65b9092012-05-30 16:32:05 +01002613 xkb_info_destroy(&seat->xkb_info);
Daniel Stone994679a2012-05-30 16:31:43 +01002614
Daniel Stone37816df2012-05-16 18:45:18 +01002615 wl_seat_release(&seat->seat);
Pekka Paalanen07753fb2012-01-02 15:31:01 +02002616}
2617
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002618static void
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002619drag_surface_configure(struct weston_surface *es, int32_t sx, int32_t sy)
2620{
2621 weston_surface_configure(es,
2622 es->geometry.x + sx, es->geometry.y + sy,
2623 es->buffer->width, es->buffer->height);
2624}
2625
2626static int
Daniel Stone37816df2012-05-16 18:45:18 +01002627device_setup_new_drag_surface(struct weston_seat *ws,
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002628 struct weston_surface *surface)
2629{
Daniel Stone37816df2012-05-16 18:45:18 +01002630 struct wl_seat *seat = &ws->seat;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002631
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002632 if (surface->configure) {
2633 wl_resource_post_error(&surface->surface.resource,
2634 WL_DISPLAY_ERROR_INVALID_OBJECT,
2635 "surface->configure already set");
2636 return 0;
2637 }
2638
Daniel Stone37816df2012-05-16 18:45:18 +01002639 ws->drag_surface = surface;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002640
Daniel Stone37816df2012-05-16 18:45:18 +01002641 weston_surface_set_position(ws->drag_surface,
2642 wl_fixed_to_double(seat->pointer->x),
2643 wl_fixed_to_double(seat->pointer->y));
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002644
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002645 surface->configure = drag_surface_configure;
2646
Kristian Høgsberg27e30522012-04-11 23:18:23 -04002647 wl_signal_add(&surface->surface.resource.destroy_signal,
Daniel Stone37816df2012-05-16 18:45:18 +01002648 &ws->drag_surface_destroy_listener);
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002649
2650 return 1;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002651}
2652
2653static void
Daniel Stone37816df2012-05-16 18:45:18 +01002654device_release_drag_surface(struct weston_seat *seat)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002655{
Daniel Stone37816df2012-05-16 18:45:18 +01002656 seat->drag_surface->configure = NULL;
2657 undef_region(&seat->drag_surface->input);
2658 wl_list_remove(&seat->drag_surface_destroy_listener.link);
2659 seat->drag_surface = NULL;
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002660}
2661
2662static void
Daniel Stone37816df2012-05-16 18:45:18 +01002663device_map_drag_surface(struct weston_seat *seat)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002664{
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002665 struct wl_list *list;
2666
Daniel Stone37816df2012-05-16 18:45:18 +01002667 if (weston_surface_is_mapped(seat->drag_surface) ||
2668 !seat->drag_surface->buffer)
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002669 return;
2670
Ander Conselvan de Oliveira37ffc3c2012-06-15 17:27:35 +03002671 if (seat->sprite && weston_surface_is_mapped(seat->sprite))
2672 list = &seat->sprite->layer_link;
2673 else
2674 list = &seat->compositor->cursor_layer.surface_list;
2675
2676 wl_list_insert(list, &seat->drag_surface->layer_link);
Daniel Stone37816df2012-05-16 18:45:18 +01002677 weston_surface_assign_output(seat->drag_surface);
2678 empty_region(&seat->drag_surface->input);
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002679}
2680
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002681static void
Daniel Stone37816df2012-05-16 18:45:18 +01002682weston_seat_update_drag_surface(struct wl_seat *seat,
2683 int dx, int dy)
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002684{
2685 int surface_changed = 0;
Daniel Stone37816df2012-05-16 18:45:18 +01002686 struct weston_seat *ws = (struct weston_seat *) seat;
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002687
Daniel Stone37816df2012-05-16 18:45:18 +01002688 if (!ws->drag_surface && !seat->drag_surface)
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002689 return;
2690
Daniel Stone37816df2012-05-16 18:45:18 +01002691 if (ws->drag_surface && seat->drag_surface &&
2692 (&ws->drag_surface->surface.resource !=
2693 &seat->drag_surface->resource))
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002694 /* between calls to this funcion we got a new drag_surface */
2695 surface_changed = 1;
2696
Daniel Stone37816df2012-05-16 18:45:18 +01002697 if (!seat->drag_surface || surface_changed) {
2698 device_release_drag_surface(ws);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002699 if (!surface_changed)
2700 return;
2701 }
2702
Daniel Stone37816df2012-05-16 18:45:18 +01002703 if (!ws->drag_surface || surface_changed) {
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002704 struct weston_surface *surface = (struct weston_surface *)
Daniel Stone37816df2012-05-16 18:45:18 +01002705 seat->drag_surface;
2706 if (!device_setup_new_drag_surface(ws, surface))
Ander Conselvan de Oliveira093bfa32012-03-27 17:36:41 +03002707 return;
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002708 }
2709
Ander Conselvan de Oliveira3e3bb322012-03-01 14:09:44 +02002710 /* the client may not have attached a buffer to the drag surface
2711 * when we setup it up, so check if map is needed on every update */
Daniel Stone37816df2012-05-16 18:45:18 +01002712 device_map_drag_surface(ws);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002713
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +02002714 /* the client may have attached a buffer with a different size to
2715 * the drag surface, causing the input region to be reset */
Daniel Stone37816df2012-05-16 18:45:18 +01002716 if (region_is_undefined(&ws->drag_surface->input))
2717 empty_region(&ws->drag_surface->input);
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +02002718
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002719 if (!dx && !dy)
2720 return;
2721
Daniel Stone37816df2012-05-16 18:45:18 +01002722 weston_surface_set_position(ws->drag_surface,
2723 ws->drag_surface->geometry.x + wl_fixed_to_double(dx),
2724 ws->drag_surface->geometry.y + wl_fixed_to_double(dy));
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002725}
2726
2727WL_EXPORT void
2728weston_compositor_update_drag_surfaces(struct weston_compositor *compositor)
2729{
Daniel Stone4dab5db2012-05-30 16:31:53 +01002730 struct weston_seat *seat;
2731
2732 wl_list_for_each(seat, &compositor->seat_list, link)
2733 weston_seat_update_drag_surface(&seat->seat, 0, 0);
Ander Conselvan de Oliveira30eebc72012-02-15 17:02:57 +02002734}
2735
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002736static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04002737bind_output(struct wl_client *client,
2738 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05002739{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002740 struct weston_output *output = data;
2741 struct weston_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04002742 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002743
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04002744 resource = wl_client_add_object(client,
2745 &wl_output_interface, NULL, id, data);
2746
Casey Dahlin9074db52012-04-19 22:50:09 -04002747 wl_list_insert(&output->resource_list, &resource->link);
2748 resource->destroy = unbind_resource;
2749
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05002750 wl_output_send_geometry(resource,
2751 output->x,
2752 output->y,
2753 output->mm_width,
2754 output->mm_height,
2755 output->subpixel,
Kristian Høgsberg0e696472012-07-22 15:49:57 -04002756 output->make, output->model,
2757 WL_OUTPUT_TRANSFORM_NORMAL);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002758
2759 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05002760 wl_output_send_mode(resource,
2761 mode->flags,
2762 mode->width,
2763 mode->height,
2764 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002765 }
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002766}
2767
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002768static const char vertex_shader[] =
2769 "uniform mat4 proj;\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05002770 "attribute vec2 position;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002771 "attribute vec2 texcoord;\n"
2772 "varying vec2 v_texcoord;\n"
2773 "void main()\n"
2774 "{\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05002775 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002776 " v_texcoord = texcoord;\n"
2777 "}\n";
2778
Gwenole Beauchesne6d030492012-04-20 11:15:51 +02002779/* Declare common fragment shader uniforms */
2780#define FRAGMENT_SHADER_UNIFORMS \
2781 "uniform float alpha;\n" \
2782 "uniform float texwidth;\n" \
2783 "uniform vec4 opaque;\n"
2784
2785/* Common fragment shader init code (check texture bounds) */
2786#define FRAGMENT_SHADER_INIT \
2787 " if (v_texcoord.x < 0.0 || v_texcoord.x > texwidth ||\n" \
2788 " v_texcoord.y < 0.0 || v_texcoord.y > 1.0)\n" \
2789 " discard;\n"
2790
2791#define FRAGMENT_SHADER_EXIT \
2792 " if (opaque.x <= v_texcoord.x && v_texcoord.x < opaque.y &&\n" \
2793 " opaque.z <= v_texcoord.y && v_texcoord.y < opaque.w)\n" \
2794 " gl_FragColor.a = 1.0;\n" \
2795 " gl_FragColor = alpha * gl_FragColor;\n"
2796
Gwenole Beauchesnefaf91852012-04-20 11:22:16 +02002797#define FRAGMENT_CONVERT_YUV \
2798 " gl_FragColor.r = y + 1.59602678 * v;\n" \
2799 " gl_FragColor.g = y - 0.39176229 * u - 0.81296764 * v;\n" \
2800 " gl_FragColor.b = y + 2.01723214 * u;\n" \
2801 " gl_FragColor.a = 1.0;\n"
2802
Gwenole Beauchesne6d030492012-04-20 11:15:51 +02002803static const char texture_fragment_shader_rgba[] =
Kristian Høgsbergdfce71d2010-12-07 20:19:10 -05002804 "precision mediump float;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002805 "varying vec2 v_texcoord;\n"
2806 "uniform sampler2D tex;\n"
Gwenole Beauchesne6d030492012-04-20 11:15:51 +02002807 FRAGMENT_SHADER_UNIFORMS
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002808 "void main()\n"
2809 "{\n"
Gwenole Beauchesne6d030492012-04-20 11:15:51 +02002810 FRAGMENT_SHADER_INIT
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002811 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
Gwenole Beauchesne6d030492012-04-20 11:15:51 +02002812 FRAGMENT_SHADER_EXIT
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002813 "}\n";
2814
Gwenole Beauchesnefaf91852012-04-20 11:22:16 +02002815static const char texture_fragment_shader_y_uv[] =
2816 "precision mediump float;\n"
2817 "uniform sampler2D tex;\n"
2818 "uniform sampler2D tex1;\n"
2819 "varying vec2 v_texcoord;\n"
2820 FRAGMENT_SHADER_UNIFORMS
2821 "void main() {\n"
2822 FRAGMENT_SHADER_INIT
2823 " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
2824 " float u = texture2D(tex1, v_texcoord).r - 0.5;\n"
2825 " float v = texture2D(tex1, v_texcoord).g - 0.5;\n"
2826 FRAGMENT_CONVERT_YUV
2827 FRAGMENT_SHADER_EXIT
2828 "}\n";
2829
2830static const char texture_fragment_shader_y_u_v[] =
2831 "precision mediump float;\n"
2832 "uniform sampler2D tex;\n"
2833 "uniform sampler2D tex1;\n"
2834 "uniform sampler2D tex2;\n"
2835 "varying vec2 v_texcoord;\n"
2836 FRAGMENT_SHADER_UNIFORMS
2837 "void main() {\n"
2838 FRAGMENT_SHADER_INIT
2839 " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
2840 " float u = texture2D(tex1, v_texcoord).x - 0.5;\n"
2841 " float v = texture2D(tex2, v_texcoord).x - 0.5;\n"
2842 FRAGMENT_CONVERT_YUV
2843 FRAGMENT_SHADER_EXIT
2844 "}\n";
2845
2846static const char texture_fragment_shader_y_xuxv[] =
2847 "precision mediump float;\n"
2848 "uniform sampler2D tex;\n"
2849 "uniform sampler2D tex1;\n"
2850 "varying vec2 v_texcoord;\n"
2851 FRAGMENT_SHADER_UNIFORMS
2852 "void main() {\n"
2853 FRAGMENT_SHADER_INIT
2854 " float y = 1.16438356 * (texture2D(tex, v_texcoord).x - 0.0625);\n"
2855 " float u = texture2D(tex1, v_texcoord).g - 0.5;\n"
2856 " float v = texture2D(tex1, v_texcoord).a - 0.5;\n"
2857 FRAGMENT_CONVERT_YUV
2858 FRAGMENT_SHADER_EXIT
2859 "}\n";
2860
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002861static const char solid_fragment_shader[] =
2862 "precision mediump float;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002863 "uniform vec4 color;\n"
Kristian Høgsbergdbae80e2012-03-29 11:34:39 -04002864 "uniform float alpha;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002865 "void main()\n"
2866 "{\n"
Kristian Høgsbergdbae80e2012-03-29 11:34:39 -04002867 " gl_FragColor = alpha * color\n;"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002868 "}\n";
2869
Kristian Høgsberga9468212010-06-14 21:03:11 -04002870static int
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002871compile_shader(GLenum type, const char *source)
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002872{
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002873 GLuint s;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002874 char msg[512];
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002875 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002876
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002877 s = glCreateShader(type);
2878 glShaderSource(s, 1, &source, NULL);
2879 glCompileShader(s);
2880 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002881 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002882 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
Martin Minarik6d118362012-06-07 18:01:59 +02002883 weston_log("shader info: %s\n", msg);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002884 return GL_NONE;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002885 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002886
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002887 return s;
2888}
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002889
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002890static int
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002891weston_shader_init(struct weston_shader *shader,
2892 const char *vertex_source, const char *fragment_source)
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002893{
2894 char msg[512];
2895 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002896
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002897 shader->vertex_shader =
2898 compile_shader(GL_VERTEX_SHADER, vertex_source);
2899 shader->fragment_shader =
2900 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
2901
2902 shader->program = glCreateProgram();
2903 glAttachShader(shader->program, shader->vertex_shader);
2904 glAttachShader(shader->program, shader->fragment_shader);
2905 glBindAttribLocation(shader->program, 0, "position");
2906 glBindAttribLocation(shader->program, 1, "texcoord");
2907
2908 glLinkProgram(shader->program);
2909 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002910 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002911 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
Martin Minarik6d118362012-06-07 18:01:59 +02002912 weston_log("link info: %s\n", msg);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002913 return -1;
2914 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002915
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002916 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +02002917 shader->tex_uniforms[0] = glGetUniformLocation(shader->program, "tex");
2918 shader->tex_uniforms[1] = glGetUniformLocation(shader->program, "tex1");
2919 shader->tex_uniforms[2] = glGetUniformLocation(shader->program, "tex2");
Kristian Høgsberg541e5552011-12-14 09:24:11 -05002920 shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
Pekka Paalanenf55f5442012-02-02 16:49:05 +02002921 shader->color_uniform = glGetUniformLocation(shader->program, "color");
Scott Moreau9fb98242012-05-22 10:18:50 -06002922 shader->texwidth_uniform = glGetUniformLocation(shader->program, "texwidth");
2923 shader->opaque_uniform = glGetUniformLocation(shader->program, "opaque");
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002924
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04002925 return 0;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04002926}
2927
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002928WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002929weston_output_destroy(struct weston_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002930{
Benjamin Franzkeb6879402012-04-10 18:28:54 +02002931 struct weston_compositor *c = output->compositor;
2932
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04002933 pixman_region32_fini(&output->region);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04002934 pixman_region32_fini(&output->previous_damage);
Casey Dahlin9074db52012-04-19 22:50:09 -04002935 output->compositor->output_id_pool &= ~(1 << output->id);
Benjamin Franzkeb6879402012-04-10 18:28:54 +02002936
2937 wl_display_remove_global(c->wl_display, output->global);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002938}
2939
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002940WL_EXPORT void
Scott Moreauccbf29d2012-02-22 14:21:41 -07002941weston_output_update_matrix(struct weston_output *output)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002942{
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01002943 int flip;
Scott Moreau850ca422012-05-21 15:21:25 -06002944 float magnification;
Scott Moreauccbf29d2012-02-22 14:21:41 -07002945 struct weston_matrix camera;
2946 struct weston_matrix modelview;
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05002947
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002948 weston_matrix_init(&output->matrix);
2949 weston_matrix_translate(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002950 -(output->x + (output->border.right + output->current->width - output->border.left) / 2.0),
2951 -(output->y + (output->border.bottom + output->current->height - output->border.top) / 2.0), 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01002952
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002953 flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002954 weston_matrix_scale(&output->matrix,
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002955 2.0 / (output->current->width + output->border.left + output->border.right),
2956 flip * 2.0 / (output->current->height + output->border.top + output->border.bottom), 1);
Scott Moreau850ca422012-05-21 15:21:25 -06002957
Scott Moreauccbf29d2012-02-22 14:21:41 -07002958 if (output->zoom.active) {
Scott Moreaue6603982012-06-11 13:07:51 -06002959 magnification = 1 / (1 - output->zoom.spring_z.current);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002960 weston_matrix_init(&camera);
2961 weston_matrix_init(&modelview);
Scott Moreau8dacaab2012-06-17 18:10:58 -06002962 weston_output_update_zoom(output, output->zoom.type);
Scott Moreaue6603982012-06-11 13:07:51 -06002963 weston_matrix_translate(&camera, output->zoom.trans_x,
2964 flip * output->zoom.trans_y, 0);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002965 weston_matrix_invert(&modelview, &camera);
Scott Moreau850ca422012-05-21 15:21:25 -06002966 weston_matrix_scale(&modelview, magnification, magnification, 1.0);
Scott Moreauccbf29d2012-02-22 14:21:41 -07002967 weston_matrix_multiply(&output->matrix, &modelview);
2968 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002969
Scott Moreauccbf29d2012-02-22 14:21:41 -07002970 output->dirty = 0;
2971}
2972
2973WL_EXPORT void
2974weston_output_move(struct weston_output *output, int x, int y)
2975{
2976 output->x = x;
2977 output->y = y;
2978
2979 pixman_region32_init(&output->previous_damage);
2980 pixman_region32_init_rect(&output->region, x, y,
2981 output->current->width,
2982 output->current->height);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002983}
2984
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002985WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002986weston_output_init(struct weston_output *output, struct weston_compositor *c,
2987 int x, int y, int width, int height, uint32_t flags)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01002988{
2989 output->compositor = c;
2990 output->x = x;
2991 output->y = y;
Kristian Høgsberg546a8122012-02-01 07:45:51 -05002992 output->border.top = 0;
2993 output->border.bottom = 0;
2994 output->border.left = 0;
2995 output->border.right = 0;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04002996 output->mm_width = width;
2997 output->mm_height = height;
Scott Moreauccbf29d2012-02-22 14:21:41 -07002998 output->dirty = 1;
2999
Scott Moreau429490d2012-06-17 18:10:59 -06003000 weston_output_init_zoom(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003001
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003002 output->flags = flags;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003003 weston_output_move(output, x, y);
Benjamin Franzke78db8482012-04-10 18:35:33 +02003004 weston_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003005
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -04003006 wl_signal_init(&output->frame_signal);
Scott Moreau9d1b1122012-06-08 19:40:53 -06003007 wl_list_init(&output->animation_list);
Casey Dahlin9074db52012-04-19 22:50:09 -04003008 wl_list_init(&output->resource_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02003009
Casey Dahlin58ba1372012-04-19 22:50:08 -04003010 output->id = ffs(~output->compositor->output_id_pool) - 1;
3011 output->compositor->output_id_pool |= 1 << output->id;
3012
Benjamin Franzkeb6879402012-04-10 18:28:54 +02003013 output->global =
3014 wl_display_add_global(c->wl_display, &wl_output_interface,
3015 output, bind_output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003016}
3017
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01003018static void
Kristian Høgsberga8873122011-11-23 10:39:34 -05003019compositor_bind(struct wl_client *client,
3020 void *data, uint32_t version, uint32_t id)
3021{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003022 struct weston_compositor *compositor = data;
Kristian Høgsberga8873122011-11-23 10:39:34 -05003023
3024 wl_client_add_object(client, &wl_compositor_interface,
3025 &compositor_interface, id, compositor);
3026}
3027
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04003028static void
Martin Minarikf12c2872012-06-11 00:57:39 +02003029log_uname(void)
3030{
3031 struct utsname usys;
3032
3033 uname(&usys);
3034
3035 weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release,
3036 usys.version, usys.machine);
3037}
3038
3039static void
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04003040log_extensions(const char *name, const char *extensions)
3041{
3042 const char *p, *end;
3043 int l;
3044
3045 l = weston_log("%s:", name);
3046 p = extensions;
3047 while (*p) {
3048 end = strchrnul(p, ' ');
3049 if (l + (end - p) > 78)
Pekka Paalanen4e4167d2012-06-11 14:06:05 +03003050 l = weston_log_continue("\n" STAMP_SPACE "%.*s",
3051 end - p, p);
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04003052 else
3053 l += weston_log_continue(" %.*s", end - p, p);
3054 for (p = end; isspace(*p); p++)
3055 ;
3056 }
3057 weston_log_continue("\n");
3058}
3059
Pekka Paalanen4e4167d2012-06-11 14:06:05 +03003060static void
3061log_egl_gl_info(EGLDisplay egldpy)
3062{
3063 const char *str;
3064
3065 str = eglQueryString(egldpy, EGL_VERSION);
3066 weston_log("EGL version: %s\n", str ? str : "(null)");
3067
3068 str = eglQueryString(egldpy, EGL_VENDOR);
3069 weston_log("EGL vendor: %s\n", str ? str : "(null)");
3070
3071 str = eglQueryString(egldpy, EGL_CLIENT_APIS);
3072 weston_log("EGL client APIs: %s\n", str ? str : "(null)");
3073
3074 str = eglQueryString(egldpy, EGL_EXTENSIONS);
3075 log_extensions("EGL extensions", str ? str : "(null)");
3076
3077 str = (char *)glGetString(GL_VERSION);
3078 weston_log("GL version: %s\n", str ? str : "(null)");
3079
3080 str = (char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
3081 weston_log("GLSL version: %s\n", str ? str : "(null)");
3082
3083 str = (char *)glGetString(GL_VENDOR);
3084 weston_log("GL vendor: %s\n", str ? str : "(null)");
3085
3086 str = (char *)glGetString(GL_RENDERER);
3087 weston_log("GL renderer: %s\n", str ? str : "(null)");
3088
3089 str = (char *)glGetString(GL_EXTENSIONS);
3090 log_extensions("GL extensions", str ? str : "(null)");
3091}
3092
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003093WL_EXPORT int
Daniel Stonebaf43592012-06-01 11:11:10 -04003094weston_compositor_init(struct weston_compositor *ec,
3095 struct wl_display *display,
3096 int argc,
Daniel Stonec1be8e52012-06-01 11:14:02 -04003097 char *argv[],
3098 const char *config_file)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003099{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05003100 struct wl_event_loop *loop;
Daniel Stonee2ef43a2012-06-01 12:14:05 +01003101 struct xkb_rule_names xkb_names;
3102 const struct config_key keyboard_config_keys[] = {
3103 { "keymap_rules", CONFIG_KEY_STRING, &xkb_names.rules },
3104 { "keymap_model", CONFIG_KEY_STRING, &xkb_names.model },
3105 { "keymap_layout", CONFIG_KEY_STRING, &xkb_names.layout },
3106 { "keymap_variant", CONFIG_KEY_STRING, &xkb_names.variant },
3107 { "keymap_options", CONFIG_KEY_STRING, &xkb_names.options },
3108 };
3109 const struct config_section cs[] = {
3110 { "keyboard",
3111 keyboard_config_keys, ARRAY_LENGTH(keyboard_config_keys) },
3112 };
3113
3114 memset(&xkb_names, 0, sizeof(xkb_names));
3115 parse_config_file(config_file, cs, ARRAY_LENGTH(cs), ec);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003116
Kristian Høgsbergf9212892008-10-11 18:40:23 -04003117 ec->wl_display = display;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003118 wl_signal_init(&ec->destroy_signal);
3119 wl_signal_init(&ec->activate_signal);
3120 wl_signal_init(&ec->lock_signal);
3121 wl_signal_init(&ec->unlock_signal);
Jan Arne Petersen42feced2012-06-21 21:52:17 +02003122 wl_signal_init(&ec->show_input_panel_signal);
3123 wl_signal_init(&ec->hide_input_panel_signal);
Benjamin Franzkebfeda132012-01-30 14:04:04 +01003124 ec->launcher_sock = weston_environment_get_fd("WESTON_LAUNCHER_SOCK");
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003125
Casey Dahlin58ba1372012-04-19 22:50:08 -04003126 ec->output_id_pool = 0;
3127
Kristian Høgsberga8873122011-11-23 10:39:34 -05003128 if (!wl_display_add_global(display, &wl_compositor_interface,
3129 ec, compositor_bind))
3130 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05003131
Daniel Stone725c2c32012-06-22 14:04:36 +01003132 wl_list_init(&ec->surface_list);
3133 wl_list_init(&ec->layer_list);
3134 wl_list_init(&ec->seat_list);
3135 wl_list_init(&ec->output_list);
3136 wl_list_init(&ec->key_binding_list);
3137 wl_list_init(&ec->button_binding_list);
3138 wl_list_init(&ec->axis_binding_list);
3139 wl_list_init(&ec->fade.animation.link);
3140
3141 weston_compositor_xkb_init(ec, &xkb_names);
3142
3143 ec->ping_handler = NULL;
3144
3145 screenshooter_create(ec);
3146 text_cursor_position_notifier_create(ec);
3147 input_method_create(ec);
3148
3149 wl_data_device_manager_init(ec->wl_display);
3150
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04003151 wl_display_init_shm(display);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003152
Daniel Stone725c2c32012-06-22 14:04:36 +01003153 loop = wl_display_get_event_loop(ec->wl_display);
3154 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
3155 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
3156
3157 ec->input_loop = wl_event_loop_create();
3158
3159 return 0;
3160}
3161
3162WL_EXPORT int
3163weston_compositor_init_gl(struct weston_compositor *ec)
3164{
3165 const char *extensions;
3166
Kristian Høgsberg362b6722012-06-18 15:13:51 -04003167 log_egl_gl_info(ec->egl_display);
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04003168
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003169 ec->image_target_texture_2d =
3170 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
3171 ec->image_target_renderbuffer_storage = (void *)
3172 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
3173 ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
3174 ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
3175 ec->bind_display =
3176 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
3177 ec->unbind_display =
3178 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
Gwenole Beauchesne28f59b02012-04-20 11:44:06 +02003179 ec->query_buffer =
3180 (void *) eglGetProcAddress("eglQueryWaylandBufferWL");
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003181
3182 extensions = (const char *) glGetString(GL_EXTENSIONS);
Pekka Paalanen299e58d2012-04-12 14:45:35 +03003183 if (!extensions) {
Martin Minarik6d118362012-06-07 18:01:59 +02003184 weston_log("Retrieving GL extension string failed.\n");
Pekka Paalanen299e58d2012-04-12 14:45:35 +03003185 return -1;
3186 }
3187
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003188 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
Martin Minarik6d118362012-06-07 18:01:59 +02003189 weston_log("GL_EXT_texture_format_BGRA8888 not available\n");
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003190 return -1;
3191 }
3192
Pekka Paalanena1d57db2012-04-17 15:02:08 +03003193 if (strstr(extensions, "GL_EXT_read_format_bgra"))
3194 ec->read_format = GL_BGRA_EXT;
3195 else
3196 ec->read_format = GL_RGBA;
Kristian Høgsbergf9247dd2012-03-27 15:25:46 -04003197
Pekka Paalanen52bfbaa2012-04-11 16:19:37 +03003198 if (strstr(extensions, "GL_EXT_unpack_subimage"))
3199 ec->has_unpack_subimage = 1;
Kristian Høgsbergfb6de222012-03-27 17:10:13 -04003200
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003201 extensions =
Kristian Høgsberg362b6722012-06-18 15:13:51 -04003202 (const char *) eglQueryString(ec->egl_display, EGL_EXTENSIONS);
Pekka Paalanen299e58d2012-04-12 14:45:35 +03003203 if (!extensions) {
Martin Minarik6d118362012-06-07 18:01:59 +02003204 weston_log("Retrieving EGL extension string failed.\n");
Pekka Paalanen299e58d2012-04-12 14:45:35 +03003205 return -1;
3206 }
3207
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003208 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
3209 ec->has_bind_display = 1;
3210 if (ec->has_bind_display)
Kristian Høgsberg362b6722012-06-18 15:13:51 -04003211 ec->bind_display(ec->egl_display, ec->wl_display);
Kristian Høgsberg3d5bae02010-10-06 21:17:40 -04003212
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003213 weston_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04003214 ec->fade.animation.frame = fade_frame;
Kristian Høgsberg3555d092011-04-11 13:58:13 -04003215
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05003216 weston_layer_init(&ec->fade_layer, &ec->layer_list);
3217 weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
3218
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04003219 glActiveTexture(GL_TEXTURE0);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04003220
Gwenole Beauchesne6d030492012-04-20 11:15:51 +02003221 if (weston_shader_init(&ec->texture_shader_rgba,
3222 vertex_shader, texture_fragment_shader_rgba) < 0)
Kristian Høgsberga9468212010-06-14 21:03:11 -04003223 return -1;
Gwenole Beauchesnefaf91852012-04-20 11:22:16 +02003224 if (weston_shader_init(&ec->texture_shader_y_uv,
3225 vertex_shader, texture_fragment_shader_y_uv) < 0)
3226 return -1;
3227 if (weston_shader_init(&ec->texture_shader_y_u_v,
3228 vertex_shader, texture_fragment_shader_y_u_v) < 0)
3229 return -1;
3230 if (weston_shader_init(&ec->texture_shader_y_xuxv,
3231 vertex_shader, texture_fragment_shader_y_xuxv) < 0)
3232 return -1;
Pekka Paalanenf55f5442012-02-02 16:49:05 +02003233 if (weston_shader_init(&ec->solid_shader,
3234 vertex_shader, solid_fragment_shader) < 0)
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04003235 return -1;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05003236
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003237 weston_compositor_schedule_repaint(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04003238
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003239 return 0;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003240}
3241
Benjamin Franzkeb8263022011-08-30 11:32:47 +02003242WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003243weston_compositor_shutdown(struct weston_compositor *ec)
Matt Roper361d2ad2011-08-29 13:52:23 -07003244{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003245 struct weston_output *output, *next;
Matt Roper361d2ad2011-08-29 13:52:23 -07003246
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003247 wl_event_source_remove(ec->idle_source);
Jonas Ådahlc97af922012-03-28 22:36:09 +02003248 if (ec->input_loop_source)
3249 wl_event_source_remove(ec->input_loop_source);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003250
Matt Roper361d2ad2011-08-29 13:52:23 -07003251 /* Destroy all outputs associated with this compositor */
Tiago Vignattib303a1d2011-12-18 22:27:40 +02003252 wl_list_for_each_safe(output, next, &ec->output_list, link)
Matt Roper361d2ad2011-08-29 13:52:23 -07003253 output->destroy(output);
Pekka Paalanen4738f3b2012-01-02 15:47:07 +02003254
Daniel Stone325fc2d2012-05-30 16:31:58 +01003255 weston_binding_list_destroy_all(&ec->key_binding_list);
3256 weston_binding_list_destroy_all(&ec->button_binding_list);
3257 weston_binding_list_destroy_all(&ec->axis_binding_list);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003258
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003259 wl_array_release(&ec->vertices);
3260 wl_array_release(&ec->indices);
Jonas Ådahlc97af922012-03-28 22:36:09 +02003261
3262 wl_event_loop_destroy(ec->input_loop);
Daniel Stone816c98e2012-07-23 19:54:58 +01003263
3264 pixman_region32_fini(&ec->damage);
Matt Roper361d2ad2011-08-29 13:52:23 -07003265}
3266
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003267static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003268{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003269 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003270
Martin Minarik6d118362012-06-07 18:01:59 +02003271 weston_log("caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003272 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003273
3274 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003275}
3276
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003277static void
3278on_segv_signal(int s, siginfo_t *siginfo, void *context)
3279{
3280 void *buffer[32];
3281 int i, count;
3282 Dl_info info;
3283
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003284 /* This SIGSEGV handler will do a best-effort backtrace, and
3285 * then call the backend restore function, which will switch
3286 * back to the vt we launched from or ungrab X etc and then
3287 * raise SIGTRAP. If we run weston under gdb from X or a
3288 * different vt, and tell gdb "handle SIGSEGV nostop", this
3289 * will allow weston to switch back to gdb on crash and then
3290 * gdb will catch the crash with SIGTRAP. */
3291
Martin Minarik6d118362012-06-07 18:01:59 +02003292 weston_log("caught segv\n");
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003293
3294 count = backtrace(buffer, ARRAY_LENGTH(buffer));
3295 for (i = 0; i < count; i++) {
3296 dladdr(buffer[i], &info);
Martin Minarik6d118362012-06-07 18:01:59 +02003297 weston_log(" [%016lx] %s (%s)\n",
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003298 (long) buffer[i],
3299 info.dli_sname ? info.dli_sname : "--",
3300 info.dli_fname);
3301 }
3302
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003303 segv_compositor->restore(segv_compositor);
3304
3305 raise(SIGTRAP);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003306}
3307
3308
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003309static void *
3310load_module(const char *name, const char *entrypoint, void **handle)
3311{
3312 char path[PATH_MAX];
3313 void *module, *init;
3314
3315 if (name[0] != '/')
Chad Versacebf381902012-05-23 23:42:15 -07003316 snprintf(path, sizeof path, "%s/%s", MODULEDIR, name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003317 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02003318 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003319
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003320 weston_log("Loading module '%s'\n", path);
Kristian Høgsberg1acd9f82012-07-26 11:39:26 -04003321 module = dlopen(path, RTLD_NOW);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003322 if (!module) {
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003323 weston_log("Failed to load module: %s\n", dlerror());
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003324 return NULL;
3325 }
3326
3327 init = dlsym(module, entrypoint);
3328 if (!init) {
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003329 weston_log("Failed to lookup init function: %s\n", dlerror());
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003330 return NULL;
3331 }
3332
3333 return init;
3334}
3335
Pekka Paalanen78a0b572012-06-06 16:59:44 +03003336static const char xdg_error_message[] =
Martin Minarik37032f82012-06-18 20:15:18 +02003337 "fatal: environment variable XDG_RUNTIME_DIR is not set.\n";
3338
3339static const char xdg_wrong_message[] =
3340 "fatal: environment variable XDG_RUNTIME_DIR\n"
3341 "is set to \"%s\", which is not a directory.\n";
3342
3343static const char xdg_wrong_mode_message[] =
3344 "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n"
3345 "correctly. Unix access mode must be 0700 but is %o,\n"
3346 "and XDG_RUNTIME_DIR must be owned by the user, but is\n"
Kristian Høgsberg30334252012-06-20 14:24:21 -04003347 "owned by UID %d.\n";
Martin Minarik37032f82012-06-18 20:15:18 +02003348
3349static const char xdg_detail_message[] =
Pekka Paalanen78a0b572012-06-06 16:59:44 +03003350 "Refer to your distribution on how to get it, or\n"
3351 "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n"
3352 "on how to implement it.\n";
3353
Martin Minarik37032f82012-06-18 20:15:18 +02003354static void
3355verify_xdg_runtime_dir(void)
3356{
3357 char *dir = getenv("XDG_RUNTIME_DIR");
3358 struct stat s;
3359
3360 if (!dir) {
3361 weston_log(xdg_error_message);
3362 weston_log_continue(xdg_detail_message);
3363 exit(EXIT_FAILURE);
3364 }
3365
3366 if (stat(dir, &s) || !S_ISDIR(s.st_mode)) {
3367 weston_log(xdg_wrong_message, dir);
3368 weston_log_continue(xdg_detail_message);
3369 exit(EXIT_FAILURE);
3370 }
3371
3372 if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) {
3373 weston_log(xdg_wrong_mode_message,
3374 dir, s.st_mode & 0777, s.st_uid);
3375 weston_log_continue(xdg_detail_message);
3376 }
3377}
3378
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04003379static int
3380usage(int error_code)
3381{
3382 fprintf(stderr,
3383 "Usage: weston [OPTIONS]\n\n"
3384 "This is weston version " VERSION ", the Wayland reference compositor.\n"
3385 "Weston supports multiple backends, and depending on which backend is in use\n"
3386 "different options will be accepted.\n\n"
3387
3388
3389 "Core options:\n\n"
3390 " -B, --backend=MODULE\tBackend module, one of drm-backend.so,\n"
3391 "\t\t\t\tx11-backend.so or wayland-backend.so\n"
3392 " -S, --socket=NAME\tName of socket to listen on\n"
3393 " -i, --idle-time=SECS\tIdle time in seconds\n"
3394 " --xserver\t\tEnable X server integration\n"
3395 " --module\t\tLoad the specified module\n"
3396 " --log==FILE\t\tLog to the given file\n"
3397 " -h, --help\t\tThis help message\n\n");
3398
3399 fprintf(stderr,
3400 "Options for drm-backend.so:\n\n"
3401 " --connector=ID\tBring up only this connector\n"
3402 " --seat=SEAT\t\tThe seat that weston should run on\n"
3403 " --tty=TTY\t\tThe tty to use\n"
3404 " --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n");
3405
3406 fprintf(stderr,
3407 "Options for x11-backend.so:\n\n"
3408 " --width=WIDTH\t\tWidth of X window\n"
3409 " --height=HEIGHT\tHeight of X window\n"
3410 " --fullscreen\t\tRun in fullscreen mode\n"
3411 " --output-count=COUNT\tCreate multiple outputs\n"
3412 " --no-input\t\tDont create input devices\n\n");
3413
3414 fprintf(stderr,
3415 "Options for wayland-backend.so:\n\n"
3416 " --width=WIDTH\t\tWidth of Wayland surface\n"
3417 " --height=HEIGHT\tHeight of Wayland surface\n"
3418 " --display=DISPLAY\tWayland display to connect to\n\n");
3419
3420 exit(error_code);
3421}
3422
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003423int main(int argc, char *argv[])
3424{
Pekka Paalanen3ab72692012-06-08 17:27:28 +03003425 int ret = EXIT_SUCCESS;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003426 struct wl_display *display;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003427 struct weston_compositor *ec;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003428 struct wl_event_source *signals[4];
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003429 struct wl_event_loop *loop;
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003430 struct sigaction segv_action;
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003431 void *shell_module, *backend_module, *xserver_module;
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003432 int (*module_init)(struct weston_compositor *ec);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003433 struct weston_compositor
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003434 *(*backend_init)(struct wl_display *display,
Daniel Stonec1be8e52012-06-01 11:14:02 -04003435 int argc, char *argv[], const char *config_file);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003436 int i;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003437 char *backend = NULL;
3438 char *shell = NULL;
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003439 char *module = NULL;
Martin Minarik19e6f262012-06-07 13:08:46 +02003440 char *log = NULL;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003441 int32_t idle_time = 300;
Scott Moreaue17f6102012-04-25 10:03:06 -06003442 int32_t xserver = 0;
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04003443 int32_t help = 0;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003444 char *socket_name = NULL;
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003445 char *config_file;
3446
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04003447 const struct config_key shell_config_keys[] = {
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003448 { "type", CONFIG_KEY_STRING, &shell },
3449 };
3450
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04003451 const struct config_section cs[] = {
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003452 { "shell",
3453 shell_config_keys, ARRAY_LENGTH(shell_config_keys) },
3454 };
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04003455
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003456 const struct weston_option core_options[] = {
3457 { WESTON_OPTION_STRING, "backend", 'B', &backend },
3458 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
3459 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003460 { WESTON_OPTION_BOOLEAN, "xserver", 0, &xserver },
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003461 { WESTON_OPTION_STRING, "module", 0, &module },
Martin Minarik19e6f262012-06-07 13:08:46 +02003462 { WESTON_OPTION_STRING, "log", 0, &log },
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04003463 { WESTON_OPTION_BOOLEAN, "help", 'h', &help },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04003464 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05003465
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003466 argc = parse_options(core_options,
3467 ARRAY_LENGTH(core_options), argc, argv);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003468
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04003469 if (help)
3470 usage(EXIT_SUCCESS);
3471
Rafal Mielniczuk6e0a7d82012-06-09 15:10:28 +02003472 weston_log_file_open(log);
3473
Pekka Paalanenbce4c2b2012-06-11 14:04:21 +03003474 weston_log("%s\n"
3475 STAMP_SPACE "%s\n"
3476 STAMP_SPACE "Bug reports to: %s\n"
3477 STAMP_SPACE "Build: %s\n",
3478 PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT,
Kristian Høgsberg23cf9eb2012-06-11 12:06:30 -04003479 BUILD_ID);
Pekka Paalanen7f4d1a32012-06-11 14:06:03 +03003480 log_uname();
Kristian Høgsberga411c8b2012-06-08 16:16:52 -04003481
Martin Minarik37032f82012-06-18 20:15:18 +02003482 verify_xdg_runtime_dir();
3483
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003484 display = wl_display_create();
3485
Tiago Vignatti2116b892011-08-08 05:52:59 -07003486 loop = wl_display_get_event_loop(display);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003487 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
3488 display);
3489 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
3490 display);
3491 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
3492 display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07003493
3494 wl_list_init(&child_process_list);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003495 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
3496 NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05003497
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003498 if (!backend) {
3499 if (getenv("WAYLAND_DISPLAY"))
3500 backend = "wayland-backend.so";
3501 else if (getenv("DISPLAY"))
3502 backend = "x11-backend.so";
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003503 else
3504 backend = "drm-backend.so";
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04003505 }
3506
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003507 config_file = config_file_path("weston.ini");
3508 parse_config_file(config_file, cs, ARRAY_LENGTH(cs), shell);
Kristian Høgsberg3df63842012-07-31 14:54:48 -04003509 if (socket_name)
3510 setenv("WAYLAND_DISPLAY", socket_name, 1);
Tiago Vignatti9a206c42012-03-21 19:49:18 +02003511
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003512 backend_init = load_module(backend, "backend_init", &backend_module);
3513 if (!backend_init)
3514 exit(EXIT_FAILURE);
Kristian Høgsberga9410222011-01-14 17:22:35 -05003515
Daniel Stonec1be8e52012-06-01 11:14:02 -04003516 ec = backend_init(display, argc, argv, config_file);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05003517 if (ec == NULL) {
Pekka Paalanen33616392012-07-30 16:56:57 +03003518 weston_log("fatal: failed to create compositor\n");
Kristian Høgsberg841883b2008-12-05 11:19:56 -05003519 exit(EXIT_FAILURE);
3520 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04003521
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003522 segv_action.sa_flags = SA_SIGINFO | SA_RESETHAND;
3523 segv_action.sa_sigaction = on_segv_signal;
3524 sigemptyset(&segv_action.sa_mask);
3525 sigaction(SIGSEGV, &segv_action, NULL);
3526 segv_compositor = ec;
3527
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003528 for (i = 1; argv[i]; i++)
Pekka Paalanen33616392012-07-30 16:56:57 +03003529 weston_log("fatal: unhandled option: %s\n", argv[i]);
3530 if (argv[1]) {
3531 ret = EXIT_FAILURE;
3532 goto out;
3533 }
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003534
Daniel Stonec1be8e52012-06-01 11:14:02 -04003535 free(config_file);
Daniel Stone855028f2012-05-01 20:37:10 +01003536
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003537 ec->option_idle_time = idle_time;
3538 ec->idle_time = idle_time;
Pekka Paalanen7296e792011-12-07 16:22:00 +02003539
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003540 module_init = NULL;
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003541 if (xserver)
Tiago Vignatti629ce232012-05-23 23:04:14 +03003542 module_init = load_module("xwayland.so",
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003543 "weston_xserver_init",
3544 &xserver_module);
Pekka Paalanen33616392012-07-30 16:56:57 +03003545 if (module_init && module_init(ec) < 0) {
3546 ret = EXIT_FAILURE;
3547 goto out;
3548 }
Kristian Høgsbergd012e9d2012-04-12 10:37:23 -04003549
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003550 if (!shell)
3551 shell = "desktop-shell.so";
3552 module_init = load_module(shell, "shell_init", &shell_module);
Pekka Paalanen33616392012-07-30 16:56:57 +03003553 if (!module_init || module_init(ec) < 0) {
3554 ret = EXIT_FAILURE;
3555 goto out;
3556 }
Kristian Høgsberg306e3612012-04-12 12:54:14 -04003557
3558
3559 module_init = NULL;
3560 if (module)
3561 module_init = load_module(module, "module_init", NULL);
Pekka Paalanen33616392012-07-30 16:56:57 +03003562 if (module_init && module_init(ec) < 0) {
3563 ret = EXIT_FAILURE;
3564 goto out;
3565 }
Tiago Vignattie4faa2a2012-04-16 17:31:44 +03003566
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04003567 if (wl_display_add_socket(display, socket_name)) {
Pekka Paalanen33616392012-07-30 16:56:57 +03003568 weston_log("fatal: failed to add socket: %m\n");
3569 ret = EXIT_FAILURE;
3570 goto out;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003571 }
3572
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02003573 weston_compositor_dpms_on(ec);
Pekka Paalanenc0444e32012-01-05 16:28:21 +02003574 weston_compositor_wake(ec);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05003575
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003576 wl_display_run(display);
3577
3578 out:
Pekka Paalanen0135abe2012-01-03 10:01:20 +02003579 /* prevent further rendering while shutting down */
Kristian Høgsberg3466bc82012-01-03 11:29:15 -05003580 ec->state = WESTON_COMPOSITOR_SLEEPING;
Pekka Paalanen0135abe2012-01-03 10:01:20 +02003581
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003582 wl_signal_emit(&ec->destroy_signal, ec);
Pekka Paalanen3c647232011-12-22 13:43:43 +02003583
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003584 if (ec->has_bind_display)
Kristian Høgsberg362b6722012-06-18 15:13:51 -04003585 ec->unbind_display(ec->egl_display, display);
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05003586
Pekka Paalanen51c769f2012-01-02 16:03:26 +02003587 for (i = ARRAY_LENGTH(signals); i;)
3588 wl_event_source_remove(signals[--i]);
3589
Daniel Stone855028f2012-05-01 20:37:10 +01003590 weston_compositor_xkb_destroy(ec);
3591
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05003592 ec->destroy(ec);
Tiago Vignatti9e2be082011-12-19 00:04:46 +02003593 wl_display_destroy(display);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05003594
Martin Minarik19e6f262012-06-07 13:08:46 +02003595 weston_log_file_close();
3596
Pekka Paalanen3ab72692012-06-08 17:27:28 +03003597 return ret;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003598}