blob: 3c5c8e32c20471c15bcb4509c91be5cc52857f83 [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øgsberga9410222011-01-14 17:22:35 -050025#include "config.h"
26
Daniel Stoneb7452fe2012-06-01 12:14:06 +010027#include <fcntl.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040028#include <stdio.h>
29#include <string.h>
30#include <stdlib.h>
31#include <stdint.h>
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +010032#include <limits.h>
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -050033#include <stdarg.h>
Benjamin Franzke6f5fc692011-06-21 19:34:19 +020034#include <assert.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040035#include <sys/ioctl.h>
Daniel Stoneb7452fe2012-06-01 12:14:06 +010036#include <sys/mman.h>
Kristian Høgsberg27da5382011-06-21 17:32:25 -040037#include <sys/wait.h>
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020038#include <sys/socket.h>
Martin Minarikf12c2872012-06-11 00:57:39 +020039#include <sys/utsname.h>
Martin Minarik37032f82012-06-18 20:15:18 +020040#include <sys/stat.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040041#include <unistd.h>
Kristian Høgsberg54879822008-11-23 17:07:32 -050042#include <math.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040043#include <linux/input.h>
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -040044#include <dlfcn.h>
Kristian Høgsberg85449032011-05-02 12:11:07 -040045#include <signal.h>
Kristian Høgsberg0690da62012-01-16 11:53:54 -050046#include <setjmp.h>
Kristian Høgsberga411c8b2012-06-08 16:16:52 -040047#include <sys/time.h>
48#include <time.h>
Kristian Høgsberg890bc052008-12-30 14:31:33 -050049
Marcin Slusarz554a0da2013-02-18 13:27:22 -050050#ifdef HAVE_LIBUNWIND
51#define UNW_LOCAL_ONLY
52#include <libunwind.h>
53#endif
54
Kristian Høgsberg82863022010-06-04 21:52:02 -040055#include "compositor.h"
Jonny Lamb8ae35902013-11-26 18:19:45 +010056#include "scaler-server-protocol.h"
Pekka Paalanen51aaf642012-05-30 15:53:41 +030057#include "../shared/os-compatibility.h"
Kristian Høgsberga411c8b2012-06-08 16:16:52 -040058#include "git-version.h"
Kristian Høgsbergaf4f2aa2013-02-15 20:53:20 -050059#include "version.h"
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050060
Kristian Høgsberg27da5382011-06-21 17:32:25 -040061static struct wl_list child_process_list;
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -040062static struct weston_compositor *segv_compositor;
Kristian Høgsberg27da5382011-06-21 17:32:25 -040063
64static int
65sigchld_handler(int signal_number, void *data)
66{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -050067 struct weston_process *p;
Kristian Høgsberg27da5382011-06-21 17:32:25 -040068 int status;
69 pid_t pid;
70
Bill Spitzak027b9622012-03-17 15:22:03 -070071 pid = waitpid(-1, &status, WNOHANG);
72 if (!pid)
73 return 1;
74
Kristian Høgsberg27da5382011-06-21 17:32:25 -040075 wl_list_for_each(p, &child_process_list, link) {
76 if (p->pid == pid)
77 break;
78 }
79
80 if (&p->link == &child_process_list) {
Martin Minarik6d118362012-06-07 18:01:59 +020081 weston_log("unknown child process exited\n");
Kristian Høgsberg27da5382011-06-21 17:32:25 -040082 return 1;
83 }
84
85 wl_list_remove(&p->link);
86 p->cleanup(p, status);
87
88 return 1;
89}
90
Ander Conselvan de Oliveira5c38ef42012-12-14 13:37:25 -020091static void
Alexander Larsson0b135062013-05-28 16:23:36 +020092weston_output_transform_scale_init(struct weston_output *output,
93 uint32_t transform, uint32_t scale);
Ander Conselvan de Oliveira5c38ef42012-12-14 13:37:25 -020094
Rob Bradford27b17932013-06-26 18:08:46 +010095static void
Jason Ekstranda7af7042013-10-12 22:38:11 -050096weston_compositor_build_view_list(struct weston_compositor *compositor);
Rob Bradford27b17932013-06-26 18:08:46 +010097
Alex Wu2dda6042012-04-17 17:20:47 +080098WL_EXPORT int
Hardening57388e42013-09-18 23:56:36 +020099weston_output_switch_mode(struct weston_output *output, struct weston_mode *mode,
100 int32_t scale, enum weston_mode_switch_op op)
Alex Wu2dda6042012-04-17 17:20:47 +0800101{
Ander Conselvan de Oliveira2bbb2b82012-12-14 13:37:26 -0200102 struct weston_seat *seat;
Hardening57388e42013-09-18 23:56:36 +0200103 struct wl_resource *resource;
Ander Conselvan de Oliveira2bbb2b82012-12-14 13:37:26 -0200104 pixman_region32_t old_output_region;
Hardening57388e42013-09-18 23:56:36 +0200105 int ret, notify_mode_changed, notify_scale_changed;
106 int temporary_mode, temporary_scale;
Ander Conselvan de Oliveira5c38ef42012-12-14 13:37:25 -0200107
Alex Wu2dda6042012-04-17 17:20:47 +0800108 if (!output->switch_mode)
109 return -1;
110
Hardening57388e42013-09-18 23:56:36 +0200111 temporary_mode = (output->original_mode != 0);
112 temporary_scale = (output->current_scale != output->original_scale);
113 ret = 0;
Ander Conselvan de Oliveira5c38ef42012-12-14 13:37:25 -0200114
Hardening57388e42013-09-18 23:56:36 +0200115 notify_mode_changed = 0;
116 notify_scale_changed = 0;
117 switch(op) {
118 case WESTON_MODE_SWITCH_SET_NATIVE:
119 output->native_mode = mode;
120 if (!temporary_mode) {
121 notify_mode_changed = 1;
122 ret = output->switch_mode(output, mode);
123 if (ret < 0)
124 return ret;
125 }
126
127 output->native_scale = scale;
128 if(!temporary_scale)
129 notify_scale_changed = 1;
130 break;
131 case WESTON_MODE_SWITCH_SET_TEMPORARY:
132 if (!temporary_mode)
133 output->original_mode = output->native_mode;
134 if (!temporary_scale)
135 output->original_scale = output->native_scale;
136
137 ret = output->switch_mode(output, mode);
138 if (ret < 0)
139 return ret;
140
Hardening57388e42013-09-18 23:56:36 +0200141 output->current_scale = scale;
142 break;
143 case WESTON_MODE_SWITCH_RESTORE_NATIVE:
144 if (!temporary_mode) {
145 weston_log("already in the native mode\n");
146 return -1;
147 }
148
149 notify_mode_changed = (output->original_mode != output->native_mode);
150
151 ret = output->switch_mode(output, mode);
152 if (ret < 0)
153 return ret;
154
155 if (output->original_scale != output->native_scale) {
156 notify_scale_changed = 1;
157 scale = output->native_scale;
158 output->original_scale = scale;
159 }
160 output->original_mode = 0;
161
162 output->current_scale = output->native_scale;
163 break;
164 default:
165 weston_log("unknown weston_switch_mode_op %d\n", op);
166 break;
167 }
Alexander Larsson355748e2013-05-28 16:23:38 +0200168
Ander Conselvan de Oliveira2bbb2b82012-12-14 13:37:26 -0200169 pixman_region32_init(&old_output_region);
170 pixman_region32_copy(&old_output_region, &output->region);
171
Ander Conselvan de Oliveira5c38ef42012-12-14 13:37:25 -0200172 /* Update output region and transformation matrix */
Hardeningff39efa2013-09-18 23:56:35 +0200173 weston_output_transform_scale_init(output, output->transform, output->current_scale);
Ander Conselvan de Oliveira5c38ef42012-12-14 13:37:25 -0200174
175 pixman_region32_init(&output->previous_damage);
176 pixman_region32_init_rect(&output->region, output->x, output->y,
177 output->width, output->height);
178
179 weston_output_update_matrix(output);
180
Ander Conselvan de Oliveira2bbb2b82012-12-14 13:37:26 -0200181 /* If a pointer falls outside the outputs new geometry, move it to its
182 * lower-right corner */
183 wl_list_for_each(seat, &output->compositor->seat_list, link) {
Kristian Høgsberge3148752013-05-06 23:19:49 -0400184 struct weston_pointer *pointer = seat->pointer;
Ander Conselvan de Oliveira2bbb2b82012-12-14 13:37:26 -0200185 int32_t x, y;
186
187 if (!pointer)
188 continue;
189
190 x = wl_fixed_to_int(pointer->x);
191 y = wl_fixed_to_int(pointer->y);
192
193 if (!pixman_region32_contains_point(&old_output_region,
194 x, y, NULL) ||
195 pixman_region32_contains_point(&output->region,
196 x, y, NULL))
197 continue;
198
199 if (x >= output->x + output->width)
200 x = output->x + output->width - 1;
201 if (y >= output->y + output->height)
202 y = output->y + output->height - 1;
203
204 pointer->x = wl_fixed_from_int(x);
205 pointer->y = wl_fixed_from_int(y);
206 }
207
208 pixman_region32_fini(&old_output_region);
209
Hardening57388e42013-09-18 23:56:36 +0200210 /* notify clients of the changes */
211 if (notify_mode_changed || notify_scale_changed) {
212 wl_resource_for_each(resource, &output->resource_list) {
213 if(notify_mode_changed) {
214 wl_output_send_mode(resource,
215 mode->flags | WL_OUTPUT_MODE_CURRENT,
216 mode->width,
217 mode->height,
218 mode->refresh);
219 }
220
221 if (notify_scale_changed)
222 wl_output_send_scale(resource, scale);
223
224 if (wl_resource_get_version(resource) >= 2)
225 wl_output_send_done(resource);
226 }
227 }
228
Ander Conselvan de Oliveira5c38ef42012-12-14 13:37:25 -0200229 return ret;
Alex Wu2dda6042012-04-17 17:20:47 +0800230}
231
Kristian Høgsberg27da5382011-06-21 17:32:25 -0400232WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500233weston_watch_process(struct weston_process *process)
Kristian Høgsberg27da5382011-06-21 17:32:25 -0400234{
235 wl_list_insert(&child_process_list, &process->link);
236}
237
Benjamin Franzke06286262011-05-06 19:12:33 +0200238static void
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200239child_client_exec(int sockfd, const char *path)
240{
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500241 int clientfd;
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200242 char s[32];
Pekka Paalanenc47ddfd2011-12-08 10:44:56 +0200243 sigset_t allsigs;
244
245 /* do not give our signal mask to the new process */
246 sigfillset(&allsigs);
247 sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200248
Alexandru DAMIAN840a4212013-09-25 14:47:47 +0100249 /* Launch clients as the user. Do not lauch clients with wrong euid.*/
250 if (seteuid(getuid()) == -1) {
251 weston_log("compositor: failed seteuid\n");
252 return;
253 }
Kristian Høgsbergeb764842012-01-31 22:17:25 -0500254
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500255 /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
256 * non-CLOEXEC fd to pass through exec. */
257 clientfd = dup(sockfd);
258 if (clientfd == -1) {
Martin Minarik6d118362012-06-07 18:01:59 +0200259 weston_log("compositor: dup failed: %m\n");
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500260 return;
261 }
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200262
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500263 snprintf(s, sizeof s, "%d", clientfd);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200264 setenv("WAYLAND_SOCKET", s, 1);
265
266 if (execl(path, path, NULL) < 0)
Martin Minarik6d118362012-06-07 18:01:59 +0200267 weston_log("compositor: executing '%s' failed: %m\n",
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200268 path);
269}
270
271WL_EXPORT struct wl_client *
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500272weston_client_launch(struct weston_compositor *compositor,
273 struct weston_process *proc,
274 const char *path,
275 weston_process_cleanup_func_t cleanup)
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200276{
277 int sv[2];
278 pid_t pid;
279 struct wl_client *client;
280
Pekka Paalanendf1fd362012-08-06 14:57:03 +0300281 weston_log("launching '%s'\n", path);
282
Pekka Paalanen51aaf642012-05-30 15:53:41 +0300283 if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
Martin Minarik6d118362012-06-07 18:01:59 +0200284 weston_log("weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200285 "socketpair failed while launching '%s': %m\n",
286 path);
287 return NULL;
288 }
289
290 pid = fork();
291 if (pid == -1) {
292 close(sv[0]);
293 close(sv[1]);
Martin Minarik6d118362012-06-07 18:01:59 +0200294 weston_log("weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200295 "fork failed while launching '%s': %m\n", path);
296 return NULL;
297 }
298
299 if (pid == 0) {
300 child_client_exec(sv[1], path);
U. Artie Eoff3b64d622013-06-03 16:22:31 -0700301 _exit(-1);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200302 }
303
304 close(sv[1]);
305
306 client = wl_client_create(compositor->wl_display, sv[0]);
307 if (!client) {
308 close(sv[0]);
Martin Minarik6d118362012-06-07 18:01:59 +0200309 weston_log("weston_client_launch: "
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200310 "wl_client_create failed while launching '%s'.\n",
311 path);
312 return NULL;
313 }
314
315 proc->pid = pid;
316 proc->cleanup = cleanup;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500317 weston_watch_process(proc);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200318
319 return client;
320}
321
322static void
Pekka Paalanen5df44de2012-10-10 12:49:23 +0300323surface_handle_pending_buffer_destroy(struct wl_listener *listener, void *data)
324{
325 struct weston_surface *surface =
326 container_of(listener, struct weston_surface,
327 pending.buffer_destroy_listener);
328
329 surface->pending.buffer = NULL;
330}
331
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +0200332static void
333empty_region(pixman_region32_t *region)
334{
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +0300335 pixman_region32_fini(region);
Ander Conselvan de Oliveira90fbbd72012-02-28 17:59:33 +0200336 pixman_region32_init(region);
337}
338
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +0300339static void
340region_init_infinite(pixman_region32_t *region)
341{
342 pixman_region32_init_rect(region, INT32_MIN, INT32_MIN,
343 UINT32_MAX, UINT32_MAX);
344}
345
Pekka Paalanene67858b2013-04-25 13:57:42 +0300346static struct weston_subsurface *
347weston_surface_to_subsurface(struct weston_surface *surface);
348
Jason Ekstranda7af7042013-10-12 22:38:11 -0500349WL_EXPORT struct weston_view *
350weston_view_create(struct weston_surface *surface)
351{
352 struct weston_view *view;
353
354 view = calloc(1, sizeof *view);
355 if (view == NULL)
356 return NULL;
357
358 view->surface = surface;
359
Jason Ekstranda7af7042013-10-12 22:38:11 -0500360 /* Assign to surface */
361 wl_list_insert(&surface->views, &view->surface_link);
362
363 wl_signal_init(&view->destroy_signal);
364 wl_list_init(&view->link);
365 wl_list_init(&view->layer_link);
366
Xiong Zhang97116532013-10-23 13:58:31 +0800367 view->plane = NULL;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500368
369 pixman_region32_init(&view->clip);
370
371 view->alpha = 1.0;
372 pixman_region32_init(&view->transform.opaque);
373
374 wl_list_init(&view->geometry.transformation_list);
375 wl_list_insert(&view->geometry.transformation_list,
376 &view->transform.position.link);
377 weston_matrix_init(&view->transform.position.matrix);
378 wl_list_init(&view->geometry.child_list);
379 pixman_region32_init(&view->transform.boundingbox);
380 view->transform.dirty = 1;
381
382 view->output = NULL;
383
384 return view;
385}
386
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500387WL_EXPORT struct weston_surface *
Kristian Høgsberg18c93002012-01-27 11:58:31 -0500388weston_surface_create(struct weston_compositor *compositor)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500389{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500390 struct weston_surface *surface;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400391
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200392 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400393 if (surface == NULL)
394 return NULL;
395
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500396 wl_signal_init(&surface->destroy_signal);
397
398 surface->resource = NULL;
Kristian Høgsberg48891542012-02-23 17:38:33 -0500399
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500400 surface->compositor = compositor;
Giulio Camuffo13b85bd2013-08-13 23:10:14 +0200401 surface->ref_count = 1;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400402
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200403 surface->buffer_viewport.buffer.transform = WL_OUTPUT_TRANSFORM_NORMAL;
404 surface->buffer_viewport.buffer.scale = 1;
Pekka Paalanenf0cad482014-03-14 14:38:16 +0200405 surface->buffer_viewport.buffer.src_width = wl_fixed_from_int(-1);
406 surface->buffer_viewport.surface.width = -1;
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +0100407 surface->pending.buffer_viewport = surface->buffer_viewport;
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400408 surface->output = NULL;
Giulio Camuffo184df502013-02-21 11:29:21 +0100409 surface->pending.newly_attached = 0;
Benjamin Franzke06286262011-05-06 19:12:33 +0200410
Pekka Paalanenb0420ae2014-01-08 15:39:17 +0200411 surface->viewport_resource = NULL;
Jonny Lamb74130762013-11-26 18:19:46 +0100412
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400413 pixman_region32_init(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500414 pixman_region32_init(&surface->opaque);
Pekka Paalanen8ec4ab62012-10-10 12:49:32 +0300415 region_init_infinite(&surface->input);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400416
Jason Ekstranda7af7042013-10-12 22:38:11 -0500417 wl_list_init(&surface->views);
418
419 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500420
Pekka Paalanen5df44de2012-10-10 12:49:23 +0300421 surface->pending.buffer_destroy_listener.notify =
422 surface_handle_pending_buffer_destroy;
Pekka Paalanen8e159182012-10-10 12:49:25 +0300423 pixman_region32_init(&surface->pending.damage);
Pekka Paalanen512dde82012-10-10 12:49:27 +0300424 pixman_region32_init(&surface->pending.opaque);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +0300425 region_init_infinite(&surface->pending.input);
Pekka Paalanenbc106382012-10-10 12:49:31 +0300426 wl_list_init(&surface->pending.frame_callback_list);
Pekka Paalanen5df44de2012-10-10 12:49:23 +0300427
Pekka Paalanene67858b2013-04-25 13:57:42 +0300428 wl_list_init(&surface->subsurface_list);
429 wl_list_init(&surface->subsurface_list_pending);
430
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400431 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500432}
433
Alex Wu8811bf92012-02-28 18:07:54 +0800434WL_EXPORT void
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500435weston_surface_set_color(struct weston_surface *surface,
John Kåre Alsaker490d02a2012-09-30 02:57:21 +0200436 float red, float green, float blue, float alpha)
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500437{
John Kåre Alsaker878f4492012-11-13 19:10:23 +0100438 surface->compositor->renderer->surface_set_color(surface, red, green, blue, alpha);
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500439}
440
Kristian Høgsberge4c1a5f2012-06-18 13:17:32 -0400441WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500442weston_view_to_global_float(struct weston_view *view,
443 float sx, float sy, float *x, float *y)
Pekka Paalanenece8a012012-02-08 15:23:15 +0200444{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500445 if (view->transform.enabled) {
Pekka Paalanenece8a012012-02-08 15:23:15 +0200446 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
447
Jason Ekstranda7af7042013-10-12 22:38:11 -0500448 weston_matrix_transform(&view->transform.matrix, &v);
Pekka Paalanenece8a012012-02-08 15:23:15 +0200449
450 if (fabsf(v.f[3]) < 1e-6) {
Martin Minarik6d118362012-06-07 18:01:59 +0200451 weston_log("warning: numerical instability in "
Scott Moreau088c62e2013-02-11 04:45:38 -0700452 "%s(), divisor = %g\n", __func__,
Pekka Paalanenece8a012012-02-08 15:23:15 +0200453 v.f[3]);
454 *x = 0;
455 *y = 0;
456 return;
457 }
458
459 *x = v.f[0] / v.f[3];
460 *y = v.f[1] / v.f[3];
461 } else {
Jason Ekstranda7af7042013-10-12 22:38:11 -0500462 *x = sx + view->geometry.x;
463 *y = sy + view->geometry.y;
Pekka Paalanenece8a012012-02-08 15:23:15 +0200464 }
465}
466
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500467WL_EXPORT void
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200468weston_transformed_coord(int width, int height,
469 enum wl_output_transform transform,
Alexander Larssonedddbd12013-05-24 13:09:43 +0200470 int32_t scale,
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200471 float sx, float sy, float *bx, float *by)
472{
473 switch (transform) {
474 case WL_OUTPUT_TRANSFORM_NORMAL:
475 default:
476 *bx = sx;
477 *by = sy;
478 break;
479 case WL_OUTPUT_TRANSFORM_FLIPPED:
480 *bx = width - sx;
481 *by = sy;
482 break;
483 case WL_OUTPUT_TRANSFORM_90:
484 *bx = height - sy;
485 *by = sx;
486 break;
487 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
488 *bx = height - sy;
489 *by = width - sx;
490 break;
491 case WL_OUTPUT_TRANSFORM_180:
492 *bx = width - sx;
493 *by = height - sy;
494 break;
495 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
496 *bx = sx;
497 *by = height - sy;
498 break;
499 case WL_OUTPUT_TRANSFORM_270:
500 *bx = sy;
501 *by = width - sx;
502 break;
503 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
504 *bx = sy;
505 *by = sx;
506 break;
507 }
Alexander Larsson4ea95522013-05-22 14:41:37 +0200508
509 *bx *= scale;
510 *by *= scale;
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200511}
512
513WL_EXPORT pixman_box32_t
514weston_transformed_rect(int width, int height,
515 enum wl_output_transform transform,
Alexander Larssonedddbd12013-05-24 13:09:43 +0200516 int32_t scale,
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200517 pixman_box32_t rect)
518{
519 float x1, x2, y1, y2;
520
521 pixman_box32_t ret;
522
Alexander Larsson4ea95522013-05-22 14:41:37 +0200523 weston_transformed_coord(width, height, transform, scale,
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200524 rect.x1, rect.y1, &x1, &y1);
Alexander Larsson4ea95522013-05-22 14:41:37 +0200525 weston_transformed_coord(width, height, transform, scale,
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200526 rect.x2, rect.y2, &x2, &y2);
527
528 if (x1 <= x2) {
529 ret.x1 = x1;
530 ret.x2 = x2;
531 } else {
532 ret.x1 = x2;
533 ret.x2 = x1;
534 }
535
536 if (y1 <= y2) {
537 ret.y1 = y1;
538 ret.y2 = y2;
539 } else {
540 ret.y1 = y2;
541 ret.y2 = y1;
542 }
543
544 return ret;
545}
546
547WL_EXPORT void
Jason Ekstrand33ff6362013-10-27 22:25:01 -0500548weston_transformed_region(int width, int height,
549 enum wl_output_transform transform,
550 int32_t scale,
551 pixman_region32_t *src, pixman_region32_t *dest)
552{
553 pixman_box32_t *src_rects, *dest_rects;
554 int nrects, i;
555
556 if (transform == WL_OUTPUT_TRANSFORM_NORMAL && scale == 1) {
557 if (src != dest)
558 pixman_region32_copy(dest, src);
559 return;
560 }
561
562 src_rects = pixman_region32_rectangles(src, &nrects);
563 dest_rects = malloc(nrects * sizeof(*dest_rects));
564 if (!dest_rects)
565 return;
566
567 if (transform == WL_OUTPUT_TRANSFORM_NORMAL) {
568 memcpy(dest_rects, src_rects, nrects * sizeof(*dest_rects));
569 } else {
570 for (i = 0; i < nrects; i++) {
571 switch (transform) {
572 default:
573 case WL_OUTPUT_TRANSFORM_NORMAL:
574 dest_rects[i].x1 = src_rects[i].x1;
575 dest_rects[i].y1 = src_rects[i].y1;
576 dest_rects[i].x2 = src_rects[i].x2;
577 dest_rects[i].y2 = src_rects[i].y2;
578 break;
579 case WL_OUTPUT_TRANSFORM_90:
580 dest_rects[i].x1 = height - src_rects[i].y2;
581 dest_rects[i].y1 = src_rects[i].x1;
582 dest_rects[i].x2 = height - src_rects[i].y1;
583 dest_rects[i].y2 = src_rects[i].x2;
584 break;
585 case WL_OUTPUT_TRANSFORM_180:
586 dest_rects[i].x1 = width - src_rects[i].x2;
587 dest_rects[i].y1 = height - src_rects[i].y2;
588 dest_rects[i].x2 = width - src_rects[i].x1;
589 dest_rects[i].y2 = height - src_rects[i].y1;
590 break;
591 case WL_OUTPUT_TRANSFORM_270:
592 dest_rects[i].x1 = src_rects[i].y1;
593 dest_rects[i].y1 = width - src_rects[i].x2;
594 dest_rects[i].x2 = src_rects[i].y2;
595 dest_rects[i].y2 = width - src_rects[i].x1;
596 break;
597 case WL_OUTPUT_TRANSFORM_FLIPPED:
598 dest_rects[i].x1 = width - src_rects[i].x2;
599 dest_rects[i].y1 = src_rects[i].y1;
600 dest_rects[i].x2 = width - src_rects[i].x1;
601 dest_rects[i].y2 = src_rects[i].y2;
602 break;
603 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
604 dest_rects[i].x1 = height - src_rects[i].y2;
605 dest_rects[i].y1 = width - src_rects[i].x2;
606 dest_rects[i].x2 = height - src_rects[i].y1;
607 dest_rects[i].y2 = width - src_rects[i].x1;
608 break;
609 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
610 dest_rects[i].x1 = src_rects[i].x1;
611 dest_rects[i].y1 = height - src_rects[i].y2;
612 dest_rects[i].x2 = src_rects[i].x2;
613 dest_rects[i].y2 = height - src_rects[i].y1;
614 break;
615 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
616 dest_rects[i].x1 = src_rects[i].y1;
617 dest_rects[i].y1 = src_rects[i].x1;
618 dest_rects[i].x2 = src_rects[i].y2;
619 dest_rects[i].y2 = src_rects[i].x2;
620 break;
621 }
622 }
623 }
624
625 if (scale != 1) {
626 for (i = 0; i < nrects; i++) {
627 dest_rects[i].x1 *= scale;
628 dest_rects[i].x2 *= scale;
629 dest_rects[i].y1 *= scale;
630 dest_rects[i].y2 *= scale;
631 }
632 }
633
634 pixman_region32_clear(dest);
635 pixman_region32_init_rects(dest, dest_rects, nrects);
636 free(dest_rects);
637}
638
Jonny Lamb74130762013-11-26 18:19:46 +0100639static void
640scaler_surface_to_buffer(struct weston_surface *surface,
641 float sx, float sy, float *bx, float *by)
642{
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200643 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200644 double src_width, src_height;
645 double src_x, src_y;
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200646
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200647 if (vp->buffer.src_width == wl_fixed_from_int(-1)) {
648 if (vp->surface.width == -1) {
649 *bx = sx;
650 *by = sy;
651 return;
652 }
Jonny Lamb74130762013-11-26 18:19:46 +0100653
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200654 src_x = 0.0;
655 src_y = 0.0;
656 src_width = surface->width_from_buffer;
657 src_height = surface->height_from_buffer;
Jonny Lamb74130762013-11-26 18:19:46 +0100658 } else {
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200659 src_x = wl_fixed_to_double(vp->buffer.src_x);
660 src_y = wl_fixed_to_double(vp->buffer.src_y);
661 src_width = wl_fixed_to_double(vp->buffer.src_width);
662 src_height = wl_fixed_to_double(vp->buffer.src_height);
Jonny Lamb74130762013-11-26 18:19:46 +0100663 }
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200664
665 *bx = sx * src_width / surface->width + src_x;
666 *by = sy * src_height / surface->height + src_y;
Jonny Lamb74130762013-11-26 18:19:46 +0100667}
668
Jason Ekstrand33ff6362013-10-27 22:25:01 -0500669WL_EXPORT void
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200670weston_surface_to_buffer_float(struct weston_surface *surface,
671 float sx, float sy, float *bx, float *by)
672{
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200673 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
674
Jonny Lamb74130762013-11-26 18:19:46 +0100675 /* first transform coordinates if the scaler is set */
676 scaler_surface_to_buffer(surface, sx, sy, bx, by);
677
Jason Ekstrandd0cebc32014-04-21 20:56:46 -0500678 weston_transformed_coord(surface->width_from_buffer,
679 surface->height_from_buffer,
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200680 vp->buffer.transform, vp->buffer.scale,
Jonny Lamb74130762013-11-26 18:19:46 +0100681 *bx, *by, bx, by);
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200682}
683
Alexander Larsson4ea95522013-05-22 14:41:37 +0200684WL_EXPORT void
685weston_surface_to_buffer(struct weston_surface *surface,
686 int sx, int sy, int *bx, int *by)
687{
688 float bxf, byf;
689
Jonny Lamb74130762013-11-26 18:19:46 +0100690 weston_surface_to_buffer_float(surface,
691 sx, sy, &bxf, &byf);
692
Alexander Larsson4ea95522013-05-22 14:41:37 +0200693 *bx = floorf(bxf);
694 *by = floorf(byf);
695}
696
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200697WL_EXPORT pixman_box32_t
698weston_surface_to_buffer_rect(struct weston_surface *surface,
699 pixman_box32_t rect)
700{
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200701 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
Jonny Lamb74130762013-11-26 18:19:46 +0100702 float xf, yf;
703
704 /* first transform box coordinates if the scaler is set */
705 scaler_surface_to_buffer(surface, rect.x1, rect.y1, &xf, &yf);
706 rect.x1 = floorf(xf);
707 rect.y1 = floorf(yf);
708
709 scaler_surface_to_buffer(surface, rect.x2, rect.y2, &xf, &yf);
710 rect.x2 = floorf(xf);
711 rect.y2 = floorf(yf);
712
Jason Ekstrandd0cebc32014-04-21 20:56:46 -0500713 return weston_transformed_rect(surface->width_from_buffer,
714 surface->height_from_buffer,
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200715 vp->buffer.transform, vp->buffer.scale,
Alexander Larsson4ea95522013-05-22 14:41:37 +0200716 rect);
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200717}
718
719WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500720weston_view_move_to_plane(struct weston_view *view,
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400721 struct weston_plane *plane)
722{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500723 if (view->plane == plane)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400724 return;
725
Jason Ekstranda7af7042013-10-12 22:38:11 -0500726 weston_view_damage_below(view);
727 view->plane = plane;
728 weston_surface_damage(view->surface);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400729}
730
731WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500732weston_view_damage_below(struct weston_view *view)
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200733{
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500734 pixman_region32_t damage;
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200735
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500736 pixman_region32_init(&damage);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500737 pixman_region32_subtract(&damage, &view->transform.boundingbox,
738 &view->clip);
Xiong Zhang97116532013-10-23 13:58:31 +0800739 if (view->plane)
740 pixman_region32_union(&view->plane->damage,
741 &view->plane->damage, &damage);
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500742 pixman_region32_fini(&damage);
Kristian Høgsberga3a784a2013-11-13 21:33:43 -0800743 weston_view_schedule_repaint(view);
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200744}
745
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400746static void
747weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask)
748{
749 uint32_t different = es->output_mask ^ mask;
750 uint32_t entered = mask & different;
751 uint32_t left = es->output_mask & different;
752 struct weston_output *output;
753 struct wl_resource *resource = NULL;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500754 struct wl_client *client;
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400755
756 es->output_mask = mask;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500757 if (es->resource == NULL)
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400758 return;
759 if (different == 0)
760 return;
761
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500762 client = wl_resource_get_client(es->resource);
763
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400764 wl_list_for_each(output, &es->compositor->output_list, link) {
765 if (1 << output->id & different)
766 resource =
Jason Ekstranda0d2dde2013-06-14 10:08:01 -0500767 wl_resource_find_for_client(&output->resource_list,
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400768 client);
769 if (resource == NULL)
770 continue;
771 if (1 << output->id & entered)
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500772 wl_surface_send_enter(es->resource, resource);
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400773 if (1 << output->id & left)
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500774 wl_surface_send_leave(es->resource, resource);
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400775 }
776}
777
Zhang, Xiong Yf3012412013-12-13 22:10:53 +0200778
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400779static void
780weston_surface_assign_output(struct weston_surface *es)
781{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500782 struct weston_output *new_output;
783 struct weston_view *view;
784 pixman_region32_t region;
785 uint32_t max, area, mask;
786 pixman_box32_t *e;
787
788 new_output = NULL;
789 max = 0;
790 mask = 0;
791 pixman_region32_init(&region);
792 wl_list_for_each(view, &es->views, surface_link) {
793 if (!view->output)
794 continue;
795
796 pixman_region32_intersect(&region, &view->transform.boundingbox,
797 &view->output->region);
798
799 e = pixman_region32_extents(&region);
800 area = (e->x2 - e->x1) * (e->y2 - e->y1);
801
802 mask |= view->output_mask;
803
804 if (area >= max) {
805 new_output = view->output;
806 max = area;
807 }
808 }
809 pixman_region32_fini(&region);
810
811 es->output = new_output;
812 weston_surface_update_output_mask(es, mask);
813}
814
815static void
816weston_view_assign_output(struct weston_view *ev)
817{
818 struct weston_compositor *ec = ev->surface->compositor;
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400819 struct weston_output *output, *new_output;
820 pixman_region32_t region;
821 uint32_t max, area, mask;
822 pixman_box32_t *e;
823
824 new_output = NULL;
825 max = 0;
826 mask = 0;
827 pixman_region32_init(&region);
828 wl_list_for_each(output, &ec->output_list, link) {
Jason Ekstranda7af7042013-10-12 22:38:11 -0500829 pixman_region32_intersect(&region, &ev->transform.boundingbox,
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400830 &output->region);
831
832 e = pixman_region32_extents(&region);
833 area = (e->x2 - e->x1) * (e->y2 - e->y1);
834
835 if (area > 0)
836 mask |= 1 << output->id;
837
838 if (area >= max) {
839 new_output = output;
840 max = area;
841 }
842 }
843 pixman_region32_fini(&region);
844
Jason Ekstranda7af7042013-10-12 22:38:11 -0500845 ev->output = new_output;
846 ev->output_mask = mask;
847
848 weston_surface_assign_output(ev->surface);
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400849}
850
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200851static void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500852view_compute_bbox(struct weston_view *view, int32_t sx, int32_t sy,
853 int32_t width, int32_t height,
854 pixman_region32_t *bbox)
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200855{
John Kåre Alsaker490d02a2012-09-30 02:57:21 +0200856 float min_x = HUGE_VALF, min_y = HUGE_VALF;
857 float max_x = -HUGE_VALF, max_y = -HUGE_VALF;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200858 int32_t s[4][2] = {
859 { sx, sy },
860 { sx, sy + height },
861 { sx + width, sy },
862 { sx + width, sy + height }
863 };
John Kåre Alsaker490d02a2012-09-30 02:57:21 +0200864 float int_x, int_y;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200865 int i;
866
Pekka Paalanen7c7d4642012-09-04 13:55:44 +0300867 if (width == 0 || height == 0) {
868 /* avoid rounding empty bbox to 1x1 */
869 pixman_region32_init(bbox);
870 return;
871 }
872
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200873 for (i = 0; i < 4; ++i) {
John Kåre Alsaker490d02a2012-09-30 02:57:21 +0200874 float x, y;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500875 weston_view_to_global_float(view, s[i][0], s[i][1], &x, &y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200876 if (x < min_x)
877 min_x = x;
878 if (x > max_x)
879 max_x = x;
880 if (y < min_y)
881 min_y = y;
882 if (y > max_y)
883 max_y = y;
884 }
885
Pekka Paalanen219b9822012-02-08 15:38:37 +0200886 int_x = floorf(min_x);
887 int_y = floorf(min_y);
888 pixman_region32_init_rect(bbox, int_x, int_y,
889 ceilf(max_x) - int_x, ceilf(max_y) - int_y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200890}
891
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200892static void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500893weston_view_update_transform_disable(struct weston_view *view)
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200894{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500895 view->transform.enabled = 0;
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200896
Pekka Paalanencc2f8682012-02-13 10:34:04 +0200897 /* round off fractions when not transformed */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500898 view->geometry.x = roundf(view->geometry.x);
899 view->geometry.y = roundf(view->geometry.y);
Pekka Paalanencc2f8682012-02-13 10:34:04 +0200900
Kristian Høgsbergc1e6c8a2013-02-19 17:04:50 -0500901 /* Otherwise identity matrix, but with x and y translation. */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500902 view->transform.position.matrix.type = WESTON_MATRIX_TRANSFORM_TRANSLATE;
903 view->transform.position.matrix.d[12] = view->geometry.x;
904 view->transform.position.matrix.d[13] = view->geometry.y;
Kristian Høgsbergc1e6c8a2013-02-19 17:04:50 -0500905
Jason Ekstranda7af7042013-10-12 22:38:11 -0500906 view->transform.matrix = view->transform.position.matrix;
Kristian Høgsbergc1e6c8a2013-02-19 17:04:50 -0500907
Jason Ekstranda7af7042013-10-12 22:38:11 -0500908 view->transform.inverse = view->transform.position.matrix;
909 view->transform.inverse.d[12] = -view->geometry.x;
910 view->transform.inverse.d[13] = -view->geometry.y;
Kristian Høgsbergc1e6c8a2013-02-19 17:04:50 -0500911
Jason Ekstranda7af7042013-10-12 22:38:11 -0500912 pixman_region32_init_rect(&view->transform.boundingbox,
913 view->geometry.x,
914 view->geometry.y,
Jason Ekstrand918f2dd2013-12-02 21:01:53 -0600915 view->surface->width,
916 view->surface->height);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500917
Jason Ekstranda7af7042013-10-12 22:38:11 -0500918 if (view->alpha == 1.0) {
919 pixman_region32_copy(&view->transform.opaque,
920 &view->surface->opaque);
921 pixman_region32_translate(&view->transform.opaque,
922 view->geometry.x,
923 view->geometry.y);
Kristian Høgsberg3b4af202012-02-28 09:19:39 -0500924 }
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200925}
926
927static int
Jason Ekstranda7af7042013-10-12 22:38:11 -0500928weston_view_update_transform_enable(struct weston_view *view)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200929{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500930 struct weston_view *parent = view->geometry.parent;
931 struct weston_matrix *matrix = &view->transform.matrix;
932 struct weston_matrix *inverse = &view->transform.inverse;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200933 struct weston_transform *tform;
934
Jason Ekstranda7af7042013-10-12 22:38:11 -0500935 view->transform.enabled = 1;
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200936
937 /* Otherwise identity matrix, but with x and y translation. */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500938 view->transform.position.matrix.type = WESTON_MATRIX_TRANSFORM_TRANSLATE;
939 view->transform.position.matrix.d[12] = view->geometry.x;
940 view->transform.position.matrix.d[13] = view->geometry.y;
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200941
942 weston_matrix_init(matrix);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500943 wl_list_for_each(tform, &view->geometry.transformation_list, link)
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200944 weston_matrix_multiply(matrix, &tform->matrix);
945
Pekka Paalanen483243f2013-03-08 14:56:50 +0200946 if (parent)
947 weston_matrix_multiply(matrix, &parent->transform.matrix);
948
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200949 if (weston_matrix_invert(inverse, matrix) < 0) {
950 /* Oops, bad total transformation, not invertible */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500951 weston_log("error: weston_view %p"
952 " transformation not invertible.\n", view);
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200953 return -1;
954 }
955
Jason Ekstrand918f2dd2013-12-02 21:01:53 -0600956 view_compute_bbox(view, 0, 0,
957 view->surface->width, view->surface->height,
Jason Ekstranda7af7042013-10-12 22:38:11 -0500958 &view->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500959
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200960 return 0;
961}
962
963WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500964weston_view_update_transform(struct weston_view *view)
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200965{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500966 struct weston_view *parent = view->geometry.parent;
Pekka Paalanen483243f2013-03-08 14:56:50 +0200967
Jason Ekstranda7af7042013-10-12 22:38:11 -0500968 if (!view->transform.dirty)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200969 return;
970
Pekka Paalanen483243f2013-03-08 14:56:50 +0200971 if (parent)
Jason Ekstranda7af7042013-10-12 22:38:11 -0500972 weston_view_update_transform(parent);
Pekka Paalanen483243f2013-03-08 14:56:50 +0200973
Jason Ekstranda7af7042013-10-12 22:38:11 -0500974 view->transform.dirty = 0;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200975
Jason Ekstranda7af7042013-10-12 22:38:11 -0500976 weston_view_damage_below(view);
Pekka Paalanen96516782012-02-09 15:32:15 +0200977
Jason Ekstranda7af7042013-10-12 22:38:11 -0500978 pixman_region32_fini(&view->transform.boundingbox);
979 pixman_region32_fini(&view->transform.opaque);
980 pixman_region32_init(&view->transform.opaque);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500981
Pekka Paalanencd403622012-01-25 13:37:39 +0200982 /* transform.position is always in transformation_list */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500983 if (view->geometry.transformation_list.next ==
984 &view->transform.position.link &&
985 view->geometry.transformation_list.prev ==
986 &view->transform.position.link &&
Pekka Paalanen483243f2013-03-08 14:56:50 +0200987 !parent) {
Jason Ekstranda7af7042013-10-12 22:38:11 -0500988 weston_view_update_transform_disable(view);
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200989 } else {
Jason Ekstranda7af7042013-10-12 22:38:11 -0500990 if (weston_view_update_transform_enable(view) < 0)
991 weston_view_update_transform_disable(view);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200992 }
Pekka Paalanen96516782012-02-09 15:32:15 +0200993
Jason Ekstranda7af7042013-10-12 22:38:11 -0500994 weston_view_damage_below(view);
Pekka Paalanen96516782012-02-09 15:32:15 +0200995
Jason Ekstranda7af7042013-10-12 22:38:11 -0500996 weston_view_assign_output(view);
Tiago Vignattifb2adba2013-06-12 15:43:21 -0300997
Jason Ekstranda7af7042013-10-12 22:38:11 -0500998 wl_signal_emit(&view->surface->compositor->transform_signal,
999 view->surface);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +02001000}
1001
Pekka Paalanenddae03c2012-02-06 14:54:20 +02001002WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001003weston_view_geometry_dirty(struct weston_view *view)
Pekka Paalanenc3ce7382013-03-08 14:56:49 +02001004{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001005 struct weston_view *child;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001006
1007 /*
Jason Ekstranda7af7042013-10-12 22:38:11 -05001008 * The invariant: if view->geometry.dirty, then all views
1009 * in view->geometry.child_list have geometry.dirty too.
Pekka Paalanen483243f2013-03-08 14:56:50 +02001010 * Corollary: if not parent->geometry.dirty, then all ancestors
1011 * are not dirty.
1012 */
1013
Jason Ekstranda7af7042013-10-12 22:38:11 -05001014 if (view->transform.dirty)
Pekka Paalanen483243f2013-03-08 14:56:50 +02001015 return;
1016
Jason Ekstranda7af7042013-10-12 22:38:11 -05001017 view->transform.dirty = 1;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001018
Jason Ekstranda7af7042013-10-12 22:38:11 -05001019 wl_list_for_each(child, &view->geometry.child_list,
Pekka Paalanen483243f2013-03-08 14:56:50 +02001020 geometry.parent_link)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001021 weston_view_geometry_dirty(child);
Pekka Paalanenc3ce7382013-03-08 14:56:49 +02001022}
1023
1024WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001025weston_view_to_global_fixed(struct weston_view *view,
1026 wl_fixed_t vx, wl_fixed_t vy,
1027 wl_fixed_t *x, wl_fixed_t *y)
Daniel Stonebd3489b2012-05-08 17:17:53 +01001028{
John Kåre Alsaker490d02a2012-09-30 02:57:21 +02001029 float xf, yf;
Daniel Stonebd3489b2012-05-08 17:17:53 +01001030
Jason Ekstranda7af7042013-10-12 22:38:11 -05001031 weston_view_to_global_float(view,
1032 wl_fixed_to_double(vx),
1033 wl_fixed_to_double(vy),
1034 &xf, &yf);
Daniel Stonebd3489b2012-05-08 17:17:53 +01001035 *x = wl_fixed_from_double(xf);
1036 *y = wl_fixed_from_double(yf);
1037}
1038
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -04001039WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001040weston_view_from_global_float(struct weston_view *view,
1041 float x, float y, float *vx, float *vy)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001042{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001043 if (view->transform.enabled) {
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001044 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
1045
Jason Ekstranda7af7042013-10-12 22:38:11 -05001046 weston_matrix_transform(&view->transform.inverse, &v);
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001047
1048 if (fabsf(v.f[3]) < 1e-6) {
Martin Minarik6d118362012-06-07 18:01:59 +02001049 weston_log("warning: numerical instability in "
Jason Ekstranda7af7042013-10-12 22:38:11 -05001050 "weston_view_from_global(), divisor = %g\n",
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001051 v.f[3]);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001052 *vx = 0;
1053 *vy = 0;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001054 return;
1055 }
1056
Jason Ekstranda7af7042013-10-12 22:38:11 -05001057 *vx = v.f[0] / v.f[3];
1058 *vy = v.f[1] / v.f[3];
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001059 } else {
Jason Ekstranda7af7042013-10-12 22:38:11 -05001060 *vx = x - view->geometry.x;
1061 *vy = y - view->geometry.y;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001062 }
1063}
1064
1065WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001066weston_view_from_global_fixed(struct weston_view *view,
1067 wl_fixed_t x, wl_fixed_t y,
1068 wl_fixed_t *vx, wl_fixed_t *vy)
Daniel Stonebd3489b2012-05-08 17:17:53 +01001069{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001070 float vxf, vyf;
Daniel Stonebd3489b2012-05-08 17:17:53 +01001071
Jason Ekstranda7af7042013-10-12 22:38:11 -05001072 weston_view_from_global_float(view,
1073 wl_fixed_to_double(x),
1074 wl_fixed_to_double(y),
1075 &vxf, &vyf);
1076 *vx = wl_fixed_from_double(vxf);
1077 *vy = wl_fixed_from_double(vyf);
Daniel Stonebd3489b2012-05-08 17:17:53 +01001078}
1079
1080WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001081weston_view_from_global(struct weston_view *view,
1082 int32_t x, int32_t y, int32_t *vx, int32_t *vy)
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001083{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001084 float vxf, vyf;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001085
Jason Ekstranda7af7042013-10-12 22:38:11 -05001086 weston_view_from_global_float(view, x, y, &vxf, &vyf);
1087 *vx = floorf(vxf);
1088 *vy = floorf(vyf);
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001089}
1090
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001091WL_EXPORT void
Kristian Høgsberg98238702012-08-03 16:29:12 -04001092weston_surface_schedule_repaint(struct weston_surface *surface)
1093{
1094 struct weston_output *output;
1095
1096 wl_list_for_each(output, &surface->compositor->output_list, link)
1097 if (surface->output_mask & (1 << output->id))
1098 weston_output_schedule_repaint(output);
1099}
1100
1101WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001102weston_view_schedule_repaint(struct weston_view *view)
1103{
1104 struct weston_output *output;
1105
1106 wl_list_for_each(output, &view->surface->compositor->output_list, link)
1107 if (view->output_mask & (1 << output->id))
1108 weston_output_schedule_repaint(output);
1109}
1110
1111WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001112weston_surface_damage(struct weston_surface *surface)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001113{
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001114 pixman_region32_union_rect(&surface->damage, &surface->damage,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001115 0, 0, surface->width,
1116 surface->height);
Pekka Paalanen2267d452012-01-26 13:12:45 +02001117
Kristian Høgsberg98238702012-08-03 16:29:12 -04001118 weston_surface_schedule_repaint(surface);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001119}
1120
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001121WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001122weston_view_set_position(struct weston_view *view, float x, float y)
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +02001123{
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001124 if (view->geometry.x == x && view->geometry.y == y)
1125 return;
1126
Jason Ekstranda7af7042013-10-12 22:38:11 -05001127 view->geometry.x = x;
1128 view->geometry.y = y;
1129 weston_view_geometry_dirty(view);
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +02001130}
1131
Pekka Paalanen483243f2013-03-08 14:56:50 +02001132static void
1133transform_parent_handle_parent_destroy(struct wl_listener *listener,
1134 void *data)
1135{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001136 struct weston_view *view =
1137 container_of(listener, struct weston_view,
Pekka Paalanen483243f2013-03-08 14:56:50 +02001138 geometry.parent_destroy_listener);
1139
Jason Ekstranda7af7042013-10-12 22:38:11 -05001140 weston_view_set_transform_parent(view, NULL);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001141}
1142
1143WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001144weston_view_set_transform_parent(struct weston_view *view,
1145 struct weston_view *parent)
Pekka Paalanen483243f2013-03-08 14:56:50 +02001146{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001147 if (view->geometry.parent) {
1148 wl_list_remove(&view->geometry.parent_destroy_listener.link);
1149 wl_list_remove(&view->geometry.parent_link);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001150 }
1151
Jason Ekstranda7af7042013-10-12 22:38:11 -05001152 view->geometry.parent = parent;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001153
Jason Ekstranda7af7042013-10-12 22:38:11 -05001154 view->geometry.parent_destroy_listener.notify =
Pekka Paalanen483243f2013-03-08 14:56:50 +02001155 transform_parent_handle_parent_destroy;
1156 if (parent) {
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001157 wl_signal_add(&parent->destroy_signal,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001158 &view->geometry.parent_destroy_listener);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001159 wl_list_insert(&parent->geometry.child_list,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001160 &view->geometry.parent_link);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001161 }
1162
Jason Ekstranda7af7042013-10-12 22:38:11 -05001163 weston_view_geometry_dirty(view);
1164}
1165
1166WL_EXPORT int
1167weston_view_is_mapped(struct weston_view *view)
1168{
1169 if (view->output)
1170 return 1;
1171 else
1172 return 0;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001173}
1174
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +03001175WL_EXPORT int
1176weston_surface_is_mapped(struct weston_surface *surface)
1177{
1178 if (surface->output)
1179 return 1;
1180 else
1181 return 0;
1182}
1183
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001184static void
Jason Ekstrand5c11a332013-12-04 20:32:03 -06001185surface_set_size(struct weston_surface *surface, int32_t width, int32_t height)
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001186{
1187 struct weston_view *view;
1188
1189 if (surface->width == width && surface->height == height)
1190 return;
1191
1192 surface->width = width;
1193 surface->height = height;
1194
1195 wl_list_for_each(view, &surface->views, surface_link)
1196 weston_view_geometry_dirty(view);
1197}
1198
Jason Ekstrand5c11a332013-12-04 20:32:03 -06001199WL_EXPORT void
1200weston_surface_set_size(struct weston_surface *surface,
1201 int32_t width, int32_t height)
1202{
1203 assert(!surface->resource);
1204 surface_set_size(surface, width, height);
1205}
1206
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001207static int
1208fixed_round_up_to_int(wl_fixed_t f)
1209{
1210 return wl_fixed_to_int(wl_fixed_from_int(1) - 1 + f);
1211}
1212
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001213static void
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001214weston_surface_set_size_from_buffer(struct weston_surface *surface)
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001215{
Pekka Paalanen952b6c82014-03-14 14:38:15 +02001216 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001217 int32_t width, height;
1218
1219 if (!surface->buffer_ref.buffer) {
Jason Ekstrand5c11a332013-12-04 20:32:03 -06001220 surface_set_size(surface, 0, 0);
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001221 surface->width_from_buffer = 0;
1222 surface->height_from_buffer = 0;
Jonny Lamb74130762013-11-26 18:19:46 +01001223 return;
1224 }
1225
Pekka Paalanen952b6c82014-03-14 14:38:15 +02001226 switch (vp->buffer.transform) {
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001227 case WL_OUTPUT_TRANSFORM_90:
1228 case WL_OUTPUT_TRANSFORM_270:
1229 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
1230 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001231 width = surface->buffer_ref.buffer->height / vp->buffer.scale;
1232 height = surface->buffer_ref.buffer->width / vp->buffer.scale;
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001233 break;
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001234 default:
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001235 width = surface->buffer_ref.buffer->width / vp->buffer.scale;
1236 height = surface->buffer_ref.buffer->height / vp->buffer.scale;
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001237 break;
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001238 }
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001239
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001240 surface->width_from_buffer = width;
1241 surface->height_from_buffer = height;
1242
1243 if (vp->surface.width != -1) {
1244 surface_set_size(surface,
1245 vp->surface.width, vp->surface.height);
1246 return;
1247 }
1248
1249 if (vp->buffer.src_width != wl_fixed_from_int(-1)) {
Pekka Paalanene9317212014-04-04 14:22:13 +03001250 int32_t w = fixed_round_up_to_int(vp->buffer.src_width);
1251 int32_t h = fixed_round_up_to_int(vp->buffer.src_height);
1252
1253 surface_set_size(surface, w ?: 1, h ?: 1);
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001254 return;
1255 }
1256
Jason Ekstrand5c11a332013-12-04 20:32:03 -06001257 surface_set_size(surface, width, height);
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001258}
1259
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001260WL_EXPORT uint32_t
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001261weston_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -05001262{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001263 struct timeval tv;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -05001264
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001265 gettimeofday(&tv, NULL);
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -05001266
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001267 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -05001268}
1269
Jason Ekstranda7af7042013-10-12 22:38:11 -05001270WL_EXPORT struct weston_view *
1271weston_compositor_pick_view(struct weston_compositor *compositor,
1272 wl_fixed_t x, wl_fixed_t y,
1273 wl_fixed_t *vx, wl_fixed_t *vy)
Tiago Vignatti9d393522012-02-10 16:26:19 +02001274{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001275 struct weston_view *view;
Tiago Vignatti9d393522012-02-10 16:26:19 +02001276
Jason Ekstranda7af7042013-10-12 22:38:11 -05001277 wl_list_for_each(view, &compositor->view_list, link) {
1278 weston_view_from_global_fixed(view, x, y, vx, vy);
1279 if (pixman_region32_contains_point(&view->surface->input,
1280 wl_fixed_to_int(*vx),
1281 wl_fixed_to_int(*vy),
Daniel Stone103db7f2012-05-08 17:17:55 +01001282 NULL))
Jason Ekstranda7af7042013-10-12 22:38:11 -05001283 return view;
Tiago Vignatti9d393522012-02-10 16:26:19 +02001284 }
1285
1286 return NULL;
1287}
1288
1289static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001290weston_compositor_repick(struct weston_compositor *compositor)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001291{
Daniel Stone37816df2012-05-16 18:45:18 +01001292 struct weston_seat *seat;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001293
Kristian Høgsberg10ddd972013-10-22 12:40:54 -07001294 if (!compositor->session_active)
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -05001295 return;
1296
Daniel Stone37816df2012-05-16 18:45:18 +01001297 wl_list_for_each(seat, &compositor->seat_list, link)
Kristian Høgsberga71e8b22013-05-06 21:51:21 -04001298 weston_seat_repick(seat);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001299}
1300
Kristian Høgsbergaf7b1ff2012-06-26 21:19:23 -04001301WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001302weston_view_unmap(struct weston_view *view)
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -05001303{
Daniel Stone4dab5db2012-05-30 16:31:53 +01001304 struct weston_seat *seat;
Kristian Høgsberg867dec72012-03-01 17:09:37 -05001305
Jason Ekstranda7af7042013-10-12 22:38:11 -05001306 if (!weston_view_is_mapped(view))
1307 return;
Kristian Høgsberg867dec72012-03-01 17:09:37 -05001308
Jason Ekstranda7af7042013-10-12 22:38:11 -05001309 weston_view_damage_below(view);
1310 view->output = NULL;
Xiong Zhang97116532013-10-23 13:58:31 +08001311 view->plane = NULL;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001312 wl_list_remove(&view->layer_link);
1313 wl_list_init(&view->layer_link);
1314 wl_list_remove(&view->link);
1315 wl_list_init(&view->link);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001316 view->output_mask = 0;
1317 weston_surface_assign_output(view->surface);
1318
1319 if (weston_surface_is_mapped(view->surface))
1320 return;
1321
1322 wl_list_for_each(seat, &view->surface->compositor->seat_list, link) {
1323 if (seat->keyboard && seat->keyboard->focus == view->surface)
Kristian Høgsberge3148752013-05-06 23:19:49 -04001324 weston_keyboard_set_focus(seat->keyboard, NULL);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001325 if (seat->pointer && seat->pointer->focus == view)
Kristian Høgsberge3148752013-05-06 23:19:49 -04001326 weston_pointer_set_focus(seat->pointer,
Kristian Høgsberg02bbabb2013-05-06 22:15:05 -04001327 NULL,
1328 wl_fixed_from_int(0),
1329 wl_fixed_from_int(0));
Jason Ekstranda7af7042013-10-12 22:38:11 -05001330 if (seat->touch && seat->touch->focus == view)
Michael Fua2bb7912013-07-23 15:51:06 +08001331 weston_touch_set_focus(seat, NULL);
Daniel Stone4dab5db2012-05-30 16:31:53 +01001332 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001333}
Kristian Høgsberg867dec72012-03-01 17:09:37 -05001334
Jason Ekstranda7af7042013-10-12 22:38:11 -05001335WL_EXPORT void
1336weston_surface_unmap(struct weston_surface *surface)
1337{
1338 struct weston_view *view;
1339
1340 wl_list_for_each(view, &surface->views, surface_link)
1341 weston_view_unmap(view);
1342 surface->output = NULL;
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -05001343}
1344
Pekka Paalanen3c9b8022014-03-14 14:38:13 +02001345static void
1346weston_surface_reset_pending_buffer(struct weston_surface *surface)
1347{
1348 if (surface->pending.buffer)
1349 wl_list_remove(&surface->pending.buffer_destroy_listener.link);
1350 surface->pending.buffer = NULL;
1351 surface->pending.sx = 0;
1352 surface->pending.sy = 0;
1353 surface->pending.newly_attached = 0;
1354}
1355
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -04001356struct weston_frame_callback {
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05001357 struct wl_resource *resource;
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -04001358 struct wl_list link;
1359};
1360
Jason Ekstranda7af7042013-10-12 22:38:11 -05001361WL_EXPORT void
1362weston_view_destroy(struct weston_view *view)
1363{
1364 wl_signal_emit(&view->destroy_signal, view);
1365
1366 assert(wl_list_empty(&view->geometry.child_list));
1367
1368 if (weston_view_is_mapped(view)) {
1369 weston_view_unmap(view);
1370 weston_compositor_build_view_list(view->surface->compositor);
1371 }
1372
1373 wl_list_remove(&view->link);
1374 wl_list_remove(&view->layer_link);
1375
1376 pixman_region32_fini(&view->clip);
1377 pixman_region32_fini(&view->transform.boundingbox);
1378
1379 weston_view_set_transform_parent(view, NULL);
1380
Jason Ekstranda7af7042013-10-12 22:38:11 -05001381 wl_list_remove(&view->surface_link);
1382
1383 free(view);
1384}
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001385
1386WL_EXPORT void
1387weston_surface_destroy(struct weston_surface *surface)
Kristian Høgsberg54879822008-11-23 17:07:32 -05001388{
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -04001389 struct weston_frame_callback *cb, *next;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001390 struct weston_view *ev, *nv;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -04001391
Giulio Camuffo13b85bd2013-08-13 23:10:14 +02001392 if (--surface->ref_count > 0)
1393 return;
1394
1395 wl_signal_emit(&surface->destroy_signal, &surface->resource);
1396
Pekka Paalanene67858b2013-04-25 13:57:42 +03001397 assert(wl_list_empty(&surface->subsurface_list_pending));
1398 assert(wl_list_empty(&surface->subsurface_list));
Pekka Paalanen483243f2013-03-08 14:56:50 +02001399
Jason Ekstranda7af7042013-10-12 22:38:11 -05001400 wl_list_for_each_safe(ev, nv, &surface->views, surface_link)
1401 weston_view_destroy(ev);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001402
Pekka Paalanenbc106382012-10-10 12:49:31 +03001403 wl_list_for_each_safe(cb, next,
1404 &surface->pending.frame_callback_list, link)
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05001405 wl_resource_destroy(cb->resource);
Pekka Paalanenbc106382012-10-10 12:49:31 +03001406
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03001407 pixman_region32_fini(&surface->pending.input);
Pekka Paalanen512dde82012-10-10 12:49:27 +03001408 pixman_region32_fini(&surface->pending.opaque);
Pekka Paalanen8e159182012-10-10 12:49:25 +03001409 pixman_region32_fini(&surface->pending.damage);
1410
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001411 if (surface->pending.buffer)
1412 wl_list_remove(&surface->pending.buffer_destroy_listener.link);
1413
Pekka Paalanende685b82012-12-04 15:58:12 +02001414 weston_buffer_reference(&surface->buffer_ref, NULL);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -04001415
Pekka Paalanen402ae6d2012-01-03 10:23:24 +02001416 pixman_region32_fini(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001417 pixman_region32_fini(&surface->opaque);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03001418 pixman_region32_fini(&surface->input);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +02001419
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -04001420 wl_list_for_each_safe(cb, next, &surface->frame_callback_list, link)
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05001421 wl_resource_destroy(cb->resource);
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -04001422
Kristian Høgsberg4fa48732009-03-10 23:17:00 -04001423 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -05001424}
1425
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001426static void
1427destroy_surface(struct wl_resource *resource)
Alex Wu8811bf92012-02-28 18:07:54 +08001428{
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001429 struct weston_surface *surface = wl_resource_get_user_data(resource);
Alex Wu8811bf92012-02-28 18:07:54 +08001430
Giulio Camuffo0d379742013-11-15 22:06:15 +01001431 /* Set the resource to NULL, since we don't want to leave a
1432 * dangling pointer if the surface was refcounted and survives
1433 * the weston_surface_destroy() call. */
1434 surface->resource = NULL;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001435 weston_surface_destroy(surface);
Alex Wu8811bf92012-02-28 18:07:54 +08001436}
1437
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +01001438static void
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001439weston_buffer_destroy_handler(struct wl_listener *listener, void *data)
1440{
1441 struct weston_buffer *buffer =
1442 container_of(listener, struct weston_buffer, destroy_listener);
1443
1444 wl_signal_emit(&buffer->destroy_signal, buffer);
1445 free(buffer);
1446}
1447
Giulio Camuffoe058cd12013-12-12 14:14:29 +01001448WL_EXPORT struct weston_buffer *
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001449weston_buffer_from_resource(struct wl_resource *resource)
1450{
1451 struct weston_buffer *buffer;
1452 struct wl_listener *listener;
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08001453
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001454 listener = wl_resource_get_destroy_listener(resource,
1455 weston_buffer_destroy_handler);
1456
Kristian Høgsberg08b58c72013-08-15 12:26:42 -07001457 if (listener)
1458 return container_of(listener, struct weston_buffer,
1459 destroy_listener);
1460
1461 buffer = zalloc(sizeof *buffer);
1462 if (buffer == NULL)
1463 return NULL;
1464
1465 buffer->resource = resource;
1466 wl_signal_init(&buffer->destroy_signal);
1467 buffer->destroy_listener.notify = weston_buffer_destroy_handler;
Stanislav Vorobiovbfbb8e52013-08-29 11:36:44 +04001468 buffer->y_inverted = 1;
Kristian Høgsberg08b58c72013-08-15 12:26:42 -07001469 wl_resource_add_destroy_listener(resource, &buffer->destroy_listener);
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08001470
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001471 return buffer;
1472}
1473
1474static void
Pekka Paalanende685b82012-12-04 15:58:12 +02001475weston_buffer_reference_handle_destroy(struct wl_listener *listener,
1476 void *data)
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +01001477{
Pekka Paalanende685b82012-12-04 15:58:12 +02001478 struct weston_buffer_reference *ref =
1479 container_of(listener, struct weston_buffer_reference,
1480 destroy_listener);
1481
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001482 assert((struct weston_buffer *)data == ref->buffer);
Pekka Paalanende685b82012-12-04 15:58:12 +02001483 ref->buffer = NULL;
1484}
1485
1486WL_EXPORT void
1487weston_buffer_reference(struct weston_buffer_reference *ref,
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001488 struct weston_buffer *buffer)
Pekka Paalanende685b82012-12-04 15:58:12 +02001489{
1490 if (ref->buffer && buffer != ref->buffer) {
Kristian Høgsberg20347802013-03-04 12:07:46 -05001491 ref->buffer->busy_count--;
1492 if (ref->buffer->busy_count == 0) {
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001493 assert(wl_resource_get_client(ref->buffer->resource));
1494 wl_resource_queue_event(ref->buffer->resource,
Kristian Høgsberg20347802013-03-04 12:07:46 -05001495 WL_BUFFER_RELEASE);
1496 }
Pekka Paalanende685b82012-12-04 15:58:12 +02001497 wl_list_remove(&ref->destroy_listener.link);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001498 }
1499
Pekka Paalanende685b82012-12-04 15:58:12 +02001500 if (buffer && buffer != ref->buffer) {
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001501 buffer->busy_count++;
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001502 wl_signal_add(&buffer->destroy_signal,
Pekka Paalanende685b82012-12-04 15:58:12 +02001503 &ref->destroy_listener);
Pekka Paalanena6421c42012-12-04 15:58:10 +02001504 }
1505
Pekka Paalanende685b82012-12-04 15:58:12 +02001506 ref->buffer = buffer;
1507 ref->destroy_listener.notify = weston_buffer_reference_handle_destroy;
1508}
1509
1510static void
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001511weston_surface_attach(struct weston_surface *surface,
1512 struct weston_buffer *buffer)
Pekka Paalanende685b82012-12-04 15:58:12 +02001513{
1514 weston_buffer_reference(&surface->buffer_ref, buffer);
1515
Pekka Paalanena6421c42012-12-04 15:58:10 +02001516 if (!buffer) {
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001517 if (weston_surface_is_mapped(surface))
1518 weston_surface_unmap(surface);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001519 }
1520
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001521 surface->compositor->renderer->attach(surface, buffer);
Pekka Paalanenbb2f3f22014-03-14 14:38:11 +02001522
1523 weston_surface_set_size_from_buffer(surface);
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +01001524}
1525
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001526WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001527weston_compositor_damage_all(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001528{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001529 struct weston_output *output;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001530
1531 wl_list_for_each(output, &compositor->output_list, link)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001532 weston_output_damage(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001533}
1534
Kristian Høgsberg9f404b72012-01-26 00:11:01 -05001535WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001536weston_output_damage(struct weston_output *output)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001537{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001538 struct weston_compositor *compositor = output->compositor;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001539
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001540 pixman_region32_union(&compositor->primary_plane.damage,
1541 &compositor->primary_plane.damage,
1542 &output->region);
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001543 weston_output_schedule_repaint(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001544}
1545
Kristian Høgsberg01f941b2009-05-27 17:47:15 -04001546static void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001547surface_flush_damage(struct weston_surface *surface)
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001548{
Pekka Paalanende685b82012-12-04 15:58:12 +02001549 if (surface->buffer_ref.buffer &&
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001550 wl_shm_buffer_get(surface->buffer_ref.buffer->resource))
Kristian Høgsbergfa1be022012-09-05 22:49:55 -04001551 surface->compositor->renderer->flush_damage(surface);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001552
Jason Ekstranda7af7042013-10-12 22:38:11 -05001553 empty_region(&surface->damage);
1554}
1555
1556static void
1557view_accumulate_damage(struct weston_view *view,
1558 pixman_region32_t *opaque)
1559{
1560 pixman_region32_t damage;
1561
1562 pixman_region32_init(&damage);
1563 if (view->transform.enabled) {
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001564 pixman_box32_t *extents;
1565
Jason Ekstranda7af7042013-10-12 22:38:11 -05001566 extents = pixman_region32_extents(&view->surface->damage);
1567 view_compute_bbox(view, extents->x1, extents->y1,
1568 extents->x2 - extents->x1,
1569 extents->y2 - extents->y1,
1570 &damage);
1571 pixman_region32_translate(&damage,
1572 -view->plane->x,
1573 -view->plane->y);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001574 } else {
Jason Ekstranda7af7042013-10-12 22:38:11 -05001575 pixman_region32_copy(&damage, &view->surface->damage);
1576 pixman_region32_translate(&damage,
1577 view->geometry.x - view->plane->x,
1578 view->geometry.y - view->plane->y);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001579 }
1580
Jason Ekstranda7af7042013-10-12 22:38:11 -05001581 pixman_region32_subtract(&damage, &damage, opaque);
1582 pixman_region32_union(&view->plane->damage,
1583 &view->plane->damage, &damage);
1584 pixman_region32_fini(&damage);
1585 pixman_region32_copy(&view->clip, opaque);
1586 pixman_region32_union(opaque, opaque, &view->transform.opaque);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001587}
1588
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001589static void
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001590compositor_accumulate_damage(struct weston_compositor *ec)
1591{
1592 struct weston_plane *plane;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001593 struct weston_view *ev;
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001594 pixman_region32_t opaque, clip;
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001595
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001596 pixman_region32_init(&clip);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001597
1598 wl_list_for_each(plane, &ec->plane_list, link) {
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001599 pixman_region32_copy(&plane->clip, &clip);
1600
1601 pixman_region32_init(&opaque);
1602
Jason Ekstranda7af7042013-10-12 22:38:11 -05001603 wl_list_for_each(ev, &ec->view_list, link) {
1604 if (ev->plane != plane)
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001605 continue;
1606
Jason Ekstranda7af7042013-10-12 22:38:11 -05001607 view_accumulate_damage(ev, &opaque);
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001608 }
1609
1610 pixman_region32_union(&clip, &clip, &opaque);
1611 pixman_region32_fini(&opaque);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001612 }
1613
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001614 pixman_region32_fini(&clip);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001615
Jason Ekstranda7af7042013-10-12 22:38:11 -05001616 wl_list_for_each(ev, &ec->view_list, link)
1617 ev->surface->touched = 0;
1618
1619 wl_list_for_each(ev, &ec->view_list, link) {
1620 if (ev->surface->touched)
1621 continue;
1622 ev->surface->touched = 1;
1623
1624 surface_flush_damage(ev->surface);
1625
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001626 /* Both the renderer and the backend have seen the buffer
1627 * by now. If renderer needs the buffer, it has its own
1628 * reference set. If the backend wants to keep the buffer
1629 * around for migrating the surface into a non-primary plane
1630 * later, keep_buffer is true. Otherwise, drop the core
1631 * reference now, and allow early buffer release. This enables
1632 * clients to use single-buffering.
1633 */
Jason Ekstranda7af7042013-10-12 22:38:11 -05001634 if (!ev->surface->keep_buffer)
1635 weston_buffer_reference(&ev->surface->buffer_ref, NULL);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001636 }
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001637}
1638
1639static void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001640surface_stash_subsurface_views(struct weston_surface *surface)
Pekka Paalanene67858b2013-04-25 13:57:42 +03001641{
1642 struct weston_subsurface *sub;
1643
Pekka Paalanene67858b2013-04-25 13:57:42 +03001644 wl_list_for_each(sub, &surface->subsurface_list, parent_link) {
Jason Ekstranda7af7042013-10-12 22:38:11 -05001645 if (sub->surface == surface)
Pekka Paalanene67858b2013-04-25 13:57:42 +03001646 continue;
1647
Jason Ekstranda7af7042013-10-12 22:38:11 -05001648 wl_list_insert_list(&sub->unused_views, &sub->surface->views);
1649 wl_list_init(&sub->surface->views);
1650
1651 surface_stash_subsurface_views(sub->surface);
Pekka Paalanene67858b2013-04-25 13:57:42 +03001652 }
1653}
1654
1655static void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001656surface_free_unused_subsurface_views(struct weston_surface *surface)
Pekka Paalanene67858b2013-04-25 13:57:42 +03001657{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001658 struct weston_subsurface *sub;
1659 struct weston_view *view, *nv;
Pekka Paalanene67858b2013-04-25 13:57:42 +03001660
Jason Ekstranda7af7042013-10-12 22:38:11 -05001661 wl_list_for_each(sub, &surface->subsurface_list, parent_link) {
1662 if (sub->surface == surface)
1663 continue;
1664
1665 wl_list_for_each_safe(view, nv, &sub->unused_views, surface_link)
1666 weston_view_destroy(view);
1667
1668 surface_free_unused_subsurface_views(sub->surface);
1669 }
1670}
1671
1672static void
1673view_list_add_subsurface_view(struct weston_compositor *compositor,
1674 struct weston_subsurface *sub,
1675 struct weston_view *parent)
1676{
1677 struct weston_subsurface *child;
1678 struct weston_view *view = NULL, *iv;
1679
1680 wl_list_for_each(iv, &sub->unused_views, surface_link) {
1681 if (iv->geometry.parent == parent) {
1682 view = iv;
1683 break;
Pekka Paalanene67858b2013-04-25 13:57:42 +03001684 }
1685 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001686
1687 if (view) {
1688 /* Put it back in the surface's list of views */
1689 wl_list_remove(&view->surface_link);
1690 wl_list_insert(&sub->surface->views, &view->surface_link);
1691 } else {
1692 view = weston_view_create(sub->surface);
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001693 weston_view_set_position(view,
1694 sub->position.x,
1695 sub->position.y);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001696 weston_view_set_transform_parent(view, parent);
1697 }
1698
1699 weston_view_update_transform(view);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001700
Pekka Paalanenb188e912013-11-19 14:03:35 +02001701 if (wl_list_empty(&sub->surface->subsurface_list)) {
1702 wl_list_insert(compositor->view_list.prev, &view->link);
1703 return;
1704 }
1705
1706 wl_list_for_each(child, &sub->surface->subsurface_list, parent_link) {
1707 if (child->surface == sub->surface)
1708 wl_list_insert(compositor->view_list.prev, &view->link);
1709 else
Jason Ekstranda7af7042013-10-12 22:38:11 -05001710 view_list_add_subsurface_view(compositor, child, view);
Pekka Paalanenb188e912013-11-19 14:03:35 +02001711 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001712}
1713
1714static void
1715view_list_add(struct weston_compositor *compositor,
1716 struct weston_view *view)
1717{
1718 struct weston_subsurface *sub;
1719
1720 weston_view_update_transform(view);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001721
Pekka Paalanenb188e912013-11-19 14:03:35 +02001722 if (wl_list_empty(&view->surface->subsurface_list)) {
1723 wl_list_insert(compositor->view_list.prev, &view->link);
1724 return;
1725 }
1726
1727 wl_list_for_each(sub, &view->surface->subsurface_list, parent_link) {
1728 if (sub->surface == view->surface)
1729 wl_list_insert(compositor->view_list.prev, &view->link);
1730 else
Jason Ekstranda7af7042013-10-12 22:38:11 -05001731 view_list_add_subsurface_view(compositor, sub, view);
Pekka Paalanenb188e912013-11-19 14:03:35 +02001732 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001733}
1734
1735static void
1736weston_compositor_build_view_list(struct weston_compositor *compositor)
1737{
1738 struct weston_view *view;
1739 struct weston_layer *layer;
1740
1741 wl_list_for_each(layer, &compositor->layer_list, link)
1742 wl_list_for_each(view, &layer->view_list, layer_link)
1743 surface_stash_subsurface_views(view->surface);
1744
1745 wl_list_init(&compositor->view_list);
1746 wl_list_for_each(layer, &compositor->layer_list, link) {
1747 wl_list_for_each(view, &layer->view_list, layer_link) {
1748 view_list_add(compositor, view);
1749 }
1750 }
1751
1752 wl_list_for_each(layer, &compositor->layer_list, link)
1753 wl_list_for_each(view, &layer->view_list, layer_link)
1754 surface_free_unused_subsurface_views(view->surface);
Pekka Paalanene67858b2013-04-25 13:57:42 +03001755}
1756
David Herrmann1edf44c2013-10-22 17:11:26 +02001757static int
Rob Bradford0fb79752012-08-02 15:36:57 +01001758weston_output_repaint(struct weston_output *output, uint32_t msecs)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001759{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001760 struct weston_compositor *ec = output->compositor;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001761 struct weston_view *ev;
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001762 struct weston_animation *animation, *next;
1763 struct weston_frame_callback *cb, *cnext;
Jonas Ådahldb773762012-06-13 00:01:21 +02001764 struct wl_list frame_callback_list;
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001765 pixman_region32_t output_damage;
David Herrmann1edf44c2013-10-22 17:11:26 +02001766 int r;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001767
Ander Conselvan de Oliveirae1e23522013-12-13 22:10:55 +02001768 if (output->destroying)
1769 return 0;
1770
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001771 /* Rebuild the surface list and update surface transforms up front. */
Jason Ekstranda7af7042013-10-12 22:38:11 -05001772 weston_compositor_build_view_list(ec);
Pekka Paalanen15d60ef2012-01-27 14:38:33 +02001773
Kristian Høgsberg79af73e2012-08-03 15:45:23 -04001774 if (output->assign_planes && !output->disable_planes)
Jesse Barnes5308a5e2012-02-09 13:12:57 -08001775 output->assign_planes(output);
Kristian Høgsberg79af73e2012-08-03 15:45:23 -04001776 else
Jason Ekstranda7af7042013-10-12 22:38:11 -05001777 wl_list_for_each(ev, &ec->view_list, link)
1778 weston_view_move_to_plane(ev, &ec->primary_plane);
Kristian Høgsberg79af73e2012-08-03 15:45:23 -04001779
Pekka Paalanene67858b2013-04-25 13:57:42 +03001780 wl_list_init(&frame_callback_list);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001781 wl_list_for_each(ev, &ec->view_list, link) {
1782 /* Note: This operation is safe to do multiple times on the
1783 * same surface.
1784 */
1785 if (ev->surface->output == output) {
Pekka Paalanene67858b2013-04-25 13:57:42 +03001786 wl_list_insert_list(&frame_callback_list,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001787 &ev->surface->frame_callback_list);
1788 wl_list_init(&ev->surface->frame_callback_list);
Pekka Paalanene67858b2013-04-25 13:57:42 +03001789 }
1790 }
1791
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001792 compositor_accumulate_damage(ec);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -04001793
Ander Conselvan de Oliveira4f521732012-08-15 14:02:05 -04001794 pixman_region32_init(&output_damage);
Ander Conselvan de Oliveira4f521732012-08-15 14:02:05 -04001795 pixman_region32_intersect(&output_damage,
1796 &ec->primary_plane.damage, &output->region);
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001797 pixman_region32_subtract(&output_damage,
1798 &output_damage, &ec->primary_plane.clip);
Ander Conselvan de Oliveira4f521732012-08-15 14:02:05 -04001799
Scott Moreauccbf29d2012-02-22 14:21:41 -07001800 if (output->dirty)
1801 weston_output_update_matrix(output);
1802
David Herrmann1edf44c2013-10-22 17:11:26 +02001803 r = output->repaint(output, &output_damage);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001804
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001805 pixman_region32_fini(&output_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001806
Kristian Høgsbergef044142011-06-21 15:02:12 -04001807 output->repaint_needed = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001808
Kristian Høgsbergaa6019e2012-03-11 16:35:16 -04001809 weston_compositor_repick(ec);
1810 wl_event_loop_dispatch(ec->input_loop, 0);
1811
Jonas Ådahldb773762012-06-13 00:01:21 +02001812 wl_list_for_each_safe(cb, cnext, &frame_callback_list, link) {
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05001813 wl_callback_send_done(cb->resource, msecs);
1814 wl_resource_destroy(cb->resource);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001815 }
1816
Scott Moreaud64cf212012-06-08 19:40:54 -06001817 wl_list_for_each_safe(animation, next, &output->animation_list, link) {
Scott Moreaud64cf212012-06-08 19:40:54 -06001818 animation->frame_counter++;
Scott Moreau94b0b0c2012-06-14 01:01:56 -06001819 animation->frame(animation, output, msecs);
Scott Moreaud64cf212012-06-08 19:40:54 -06001820 }
David Herrmann1edf44c2013-10-22 17:11:26 +02001821
1822 return r;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001823}
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001824
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001825static int
1826weston_compositor_read_input(int fd, uint32_t mask, void *data)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001827{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001828 struct weston_compositor *compositor = data;
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05001829
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001830 wl_event_loop_dispatch(compositor->input_loop, 0);
1831
1832 return 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001833}
1834
1835WL_EXPORT void
Rob Bradford0fb79752012-08-02 15:36:57 +01001836weston_output_finish_frame(struct weston_output *output, uint32_t msecs)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001837{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001838 struct weston_compositor *compositor = output->compositor;
1839 struct wl_event_loop *loop =
1840 wl_display_get_event_loop(compositor->wl_display);
David Herrmann1edf44c2013-10-22 17:11:26 +02001841 int fd, r;
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001842
Kristian Høgsberge9d04922012-06-19 23:54:26 -04001843 output->frame_time = msecs;
Kristian Høgsberg991810c2013-10-16 11:10:12 -07001844
1845 if (output->repaint_needed &&
1846 compositor->state != WESTON_COMPOSITOR_SLEEPING &&
1847 compositor->state != WESTON_COMPOSITOR_OFFSCREEN) {
David Herrmann1edf44c2013-10-22 17:11:26 +02001848 r = weston_output_repaint(output, msecs);
1849 if (!r)
1850 return;
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001851 }
1852
1853 output->repaint_scheduled = 0;
1854 if (compositor->input_loop_source)
1855 return;
1856
1857 fd = wl_event_loop_get_fd(compositor->input_loop);
1858 compositor->input_loop_source =
1859 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
1860 weston_compositor_read_input, compositor);
1861}
1862
1863static void
1864idle_repaint(void *data)
1865{
1866 struct weston_output *output = data;
1867
Jonas Ådahle5a12252013-04-05 23:07:11 +02001868 output->start_repaint_loop(output);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001869}
1870
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001871WL_EXPORT void
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001872weston_layer_init(struct weston_layer *layer, struct wl_list *below)
1873{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001874 wl_list_init(&layer->view_list);
Jonas Ådahle3cddce2012-06-13 00:01:22 +02001875 if (below != NULL)
1876 wl_list_insert(below, &layer->link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001877}
1878
1879WL_EXPORT void
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001880weston_output_schedule_repaint(struct weston_output *output)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001881{
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001882 struct weston_compositor *compositor = output->compositor;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001883 struct wl_event_loop *loop;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001884
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01001885 if (compositor->state == WESTON_COMPOSITOR_SLEEPING ||
1886 compositor->state == WESTON_COMPOSITOR_OFFSCREEN)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001887 return;
1888
Kristian Høgsbergef044142011-06-21 15:02:12 -04001889 loop = wl_display_get_event_loop(compositor->wl_display);
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001890 output->repaint_needed = 1;
1891 if (output->repaint_scheduled)
1892 return;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001893
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001894 wl_event_loop_add_idle(loop, idle_repaint, output);
1895 output->repaint_scheduled = 1;
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001896
1897 if (compositor->input_loop_source) {
1898 wl_event_source_remove(compositor->input_loop_source);
1899 compositor->input_loop_source = NULL;
1900 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001901}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -05001902
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001903WL_EXPORT void
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001904weston_compositor_schedule_repaint(struct weston_compositor *compositor)
1905{
1906 struct weston_output *output;
1907
1908 wl_list_for_each(output, &compositor->output_list, link)
1909 weston_output_schedule_repaint(output);
1910}
1911
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001912static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001913surface_destroy(struct wl_client *client, struct wl_resource *resource)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001914{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001915 wl_resource_destroy(resource);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001916}
1917
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001918static void
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001919surface_attach(struct wl_client *client,
1920 struct wl_resource *resource,
1921 struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
1922{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05001923 struct weston_surface *surface = wl_resource_get_user_data(resource);
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001924 struct weston_buffer *buffer = NULL;
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001925
Kristian Høgsbergab19f932013-08-20 11:30:54 -07001926 if (buffer_resource) {
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001927 buffer = weston_buffer_from_resource(buffer_resource);
Kristian Høgsbergab19f932013-08-20 11:30:54 -07001928 if (buffer == NULL) {
1929 wl_client_post_no_memory(client);
1930 return;
1931 }
Kristian Høgsberg08b58c72013-08-15 12:26:42 -07001932 }
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001933
Pekka Paalanende685b82012-12-04 15:58:12 +02001934 /* Attach, attach, without commit in between does not send
1935 * wl_buffer.release. */
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001936 if (surface->pending.buffer)
1937 wl_list_remove(&surface->pending.buffer_destroy_listener.link);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001938
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001939 surface->pending.sx = sx;
1940 surface->pending.sy = sy;
1941 surface->pending.buffer = buffer;
Giulio Camuffo184df502013-02-21 11:29:21 +01001942 surface->pending.newly_attached = 1;
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001943 if (buffer) {
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001944 wl_signal_add(&buffer->destroy_signal,
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001945 &surface->pending.buffer_destroy_listener);
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001946 }
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001947}
1948
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001949static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001950surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001951 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001952 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -05001953{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05001954 struct weston_surface *surface = wl_resource_get_user_data(resource);
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -04001955
Pekka Paalanen8e159182012-10-10 12:49:25 +03001956 pixman_region32_union_rect(&surface->pending.damage,
1957 &surface->pending.damage,
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001958 x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001959}
1960
Kristian Høgsberg33418202011-08-16 23:01:28 -04001961static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001962destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001963{
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05001964 struct weston_frame_callback *cb = wl_resource_get_user_data(resource);
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001965
1966 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02001967 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001968}
1969
1970static void
1971surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001972 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001973{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001974 struct weston_frame_callback *cb;
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05001975 struct weston_surface *surface = wl_resource_get_user_data(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001976
1977 cb = malloc(sizeof *cb);
1978 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001979 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001980 return;
1981 }
Pekka Paalanenbc106382012-10-10 12:49:31 +03001982
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07001983 cb->resource = wl_resource_create(client, &wl_callback_interface, 1,
1984 callback);
1985 if (cb->resource == NULL) {
1986 free(cb);
1987 wl_resource_post_no_memory(resource);
1988 return;
1989 }
1990
Jason Ekstranda85118c2013-06-27 20:17:02 -05001991 wl_resource_set_implementation(cb->resource, NULL, cb,
1992 destroy_frame_callback);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001993
Pekka Paalanenbc106382012-10-10 12:49:31 +03001994 wl_list_insert(surface->pending.frame_callback_list.prev, &cb->link);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001995}
1996
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001997static void
1998surface_set_opaque_region(struct wl_client *client,
1999 struct wl_resource *resource,
2000 struct wl_resource *region_resource)
2001{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002002 struct weston_surface *surface = wl_resource_get_user_data(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002003 struct weston_region *region;
2004
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002005 if (region_resource) {
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002006 region = wl_resource_get_user_data(region_resource);
Pekka Paalanen512dde82012-10-10 12:49:27 +03002007 pixman_region32_copy(&surface->pending.opaque,
2008 &region->region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002009 } else {
Pekka Paalanen512dde82012-10-10 12:49:27 +03002010 empty_region(&surface->pending.opaque);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002011 }
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002012}
2013
2014static void
2015surface_set_input_region(struct wl_client *client,
2016 struct wl_resource *resource,
2017 struct wl_resource *region_resource)
2018{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002019 struct weston_surface *surface = wl_resource_get_user_data(resource);
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05002020 struct weston_region *region;
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002021
2022 if (region_resource) {
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002023 region = wl_resource_get_user_data(region_resource);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002024 pixman_region32_copy(&surface->pending.input,
2025 &region->region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002026 } else {
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002027 pixman_region32_fini(&surface->pending.input);
2028 region_init_infinite(&surface->pending.input);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002029 }
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002030}
2031
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002032static void
Pekka Paalanene67858b2013-04-25 13:57:42 +03002033weston_surface_commit_subsurface_order(struct weston_surface *surface)
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002034{
Pekka Paalanene67858b2013-04-25 13:57:42 +03002035 struct weston_subsurface *sub;
2036
2037 wl_list_for_each_reverse(sub, &surface->subsurface_list_pending,
2038 parent_link_pending) {
2039 wl_list_remove(&sub->parent_link);
2040 wl_list_insert(&surface->subsurface_list, &sub->parent_link);
2041 }
2042}
2043
2044static void
2045weston_surface_commit(struct weston_surface *surface)
2046{
Jason Ekstranda7af7042013-10-12 22:38:11 -05002047 struct weston_view *view;
Ander Conselvan de Oliveira5df8eca2012-10-30 17:44:01 +02002048 pixman_region32_t opaque;
2049
Pekka Paalanen260ba382014-03-14 14:38:12 +02002050 /* XXX: wl_viewport.set without an attach should call configure */
2051
Alexander Larsson4ea95522013-05-22 14:41:37 +02002052 /* wl_surface.set_buffer_transform */
Alexander Larsson4ea95522013-05-22 14:41:37 +02002053 /* wl_surface.set_buffer_scale */
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02002054 /* wl_viewport.set */
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +01002055 surface->buffer_viewport = surface->pending.buffer_viewport;
Alexander Larsson4ea95522013-05-22 14:41:37 +02002056
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002057 /* wl_surface.attach */
Pekka Paalanen260ba382014-03-14 14:38:12 +02002058 if (surface->pending.newly_attached)
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002059 weston_surface_attach(surface, surface->pending.buffer);
Giulio Camuffo184df502013-02-21 11:29:21 +01002060
2061 if (surface->configure && surface->pending.newly_attached)
Pekka Paalanenf1f48cf2013-03-08 14:56:48 +02002062 surface->configure(surface,
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06002063 surface->pending.sx, surface->pending.sy);
Giulio Camuffo184df502013-02-21 11:29:21 +01002064
Pekka Paalanen3c9b8022014-03-14 14:38:13 +02002065 weston_surface_reset_pending_buffer(surface);
Pekka Paalanen8e159182012-10-10 12:49:25 +03002066
2067 /* wl_surface.damage */
2068 pixman_region32_union(&surface->damage, &surface->damage,
2069 &surface->pending.damage);
Kristian Høgsberg4d0214c2012-11-08 11:36:02 -05002070 pixman_region32_intersect_rect(&surface->damage, &surface->damage,
2071 0, 0,
Jason Ekstranda7af7042013-10-12 22:38:11 -05002072 surface->width,
2073 surface->height);
Pekka Paalanen8e159182012-10-10 12:49:25 +03002074 empty_region(&surface->pending.damage);
Pekka Paalanen512dde82012-10-10 12:49:27 +03002075
2076 /* wl_surface.set_opaque_region */
Ander Conselvan de Oliveira5df8eca2012-10-30 17:44:01 +02002077 pixman_region32_init_rect(&opaque, 0, 0,
Jason Ekstranda7af7042013-10-12 22:38:11 -05002078 surface->width,
2079 surface->height);
Ander Conselvan de Oliveira5df8eca2012-10-30 17:44:01 +02002080 pixman_region32_intersect(&opaque,
2081 &opaque, &surface->pending.opaque);
2082
2083 if (!pixman_region32_equal(&opaque, &surface->opaque)) {
2084 pixman_region32_copy(&surface->opaque, &opaque);
Jason Ekstranda7af7042013-10-12 22:38:11 -05002085 wl_list_for_each(view, &surface->views, surface_link)
2086 weston_view_geometry_dirty(view);
Ander Conselvan de Oliveira5df8eca2012-10-30 17:44:01 +02002087 }
2088
2089 pixman_region32_fini(&opaque);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002090
2091 /* wl_surface.set_input_region */
2092 pixman_region32_fini(&surface->input);
2093 pixman_region32_init_rect(&surface->input, 0, 0,
Jason Ekstranda7af7042013-10-12 22:38:11 -05002094 surface->width,
2095 surface->height);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002096 pixman_region32_intersect(&surface->input,
2097 &surface->input, &surface->pending.input);
2098
Pekka Paalanenbc106382012-10-10 12:49:31 +03002099 /* wl_surface.frame */
2100 wl_list_insert_list(&surface->frame_callback_list,
2101 &surface->pending.frame_callback_list);
2102 wl_list_init(&surface->pending.frame_callback_list);
2103
Pekka Paalanene67858b2013-04-25 13:57:42 +03002104 weston_surface_commit_subsurface_order(surface);
2105
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002106 weston_surface_schedule_repaint(surface);
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002107}
2108
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002109static void
Pekka Paalanene67858b2013-04-25 13:57:42 +03002110weston_subsurface_commit(struct weston_subsurface *sub);
2111
2112static void
2113weston_subsurface_parent_commit(struct weston_subsurface *sub,
2114 int parent_is_synchronized);
2115
2116static void
2117surface_commit(struct wl_client *client, struct wl_resource *resource)
2118{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002119 struct weston_surface *surface = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002120 struct weston_subsurface *sub = weston_surface_to_subsurface(surface);
2121
2122 if (sub) {
2123 weston_subsurface_commit(sub);
2124 return;
2125 }
2126
2127 weston_surface_commit(surface);
2128
2129 wl_list_for_each(sub, &surface->subsurface_list, parent_link) {
2130 if (sub->surface != surface)
2131 weston_subsurface_parent_commit(sub, 0);
2132 }
2133}
2134
2135static void
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002136surface_set_buffer_transform(struct wl_client *client,
2137 struct wl_resource *resource, int transform)
2138{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002139 struct weston_surface *surface = wl_resource_get_user_data(resource);
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002140
Jonny Lamba55f1392014-05-30 12:07:15 +02002141 /* if wl_output.transform grows more members this will need to be updated. */
2142 if (transform < 0 ||
2143 transform > WL_OUTPUT_TRANSFORM_FLIPPED_270) {
2144 wl_resource_post_error(resource,
2145 WL_SURFACE_ERROR_INVALID_TRANSFORM,
2146 "buffer transform must be a valid transform "
2147 "('%d' specified)", transform);
2148 return;
2149 }
2150
Pekka Paalanen952b6c82014-03-14 14:38:15 +02002151 surface->pending.buffer_viewport.buffer.transform = transform;
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002152}
2153
Alexander Larsson4ea95522013-05-22 14:41:37 +02002154static void
2155surface_set_buffer_scale(struct wl_client *client,
2156 struct wl_resource *resource,
Alexander Larssonedddbd12013-05-24 13:09:43 +02002157 int32_t scale)
Alexander Larsson4ea95522013-05-22 14:41:37 +02002158{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002159 struct weston_surface *surface = wl_resource_get_user_data(resource);
Alexander Larsson4ea95522013-05-22 14:41:37 +02002160
Jonny Lamba55f1392014-05-30 12:07:15 +02002161 if (scale < 1) {
2162 wl_resource_post_error(resource,
2163 WL_SURFACE_ERROR_INVALID_SCALE,
2164 "buffer scale must be at least one "
2165 "('%d' specified)", scale);
2166 return;
2167 }
2168
Pekka Paalanen952b6c82014-03-14 14:38:15 +02002169 surface->pending.buffer_viewport.buffer.scale = scale;
Alexander Larsson4ea95522013-05-22 14:41:37 +02002170}
2171
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04002172static const struct wl_surface_interface surface_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002173 surface_destroy,
2174 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04002175 surface_damage,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002176 surface_frame,
2177 surface_set_opaque_region,
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002178 surface_set_input_region,
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002179 surface_commit,
Alexander Larsson4ea95522013-05-22 14:41:37 +02002180 surface_set_buffer_transform,
2181 surface_set_buffer_scale
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002182};
2183
2184static void
2185compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04002186 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002187{
Kristian Høgsbergc2d70422013-06-25 15:34:33 -04002188 struct weston_compositor *ec = wl_resource_get_user_data(resource);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002189 struct weston_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002190
Kristian Høgsberg18c93002012-01-27 11:58:31 -05002191 surface = weston_surface_create(ec);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04002192 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04002193 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002194 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04002195 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002196
Jason Ekstranda85118c2013-06-27 20:17:02 -05002197 surface->resource =
2198 wl_resource_create(client, &wl_surface_interface,
2199 wl_resource_get_version(resource), id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07002200 if (surface->resource == NULL) {
2201 weston_surface_destroy(surface);
2202 wl_resource_post_no_memory(resource);
2203 return;
2204 }
Jason Ekstranda85118c2013-06-27 20:17:02 -05002205 wl_resource_set_implementation(surface->resource, &surface_interface,
2206 surface, destroy_surface);
Kristian Høgsbergf03a04a2014-04-06 22:04:50 -07002207
2208 wl_signal_emit(&ec->create_surface_signal, surface);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002209}
2210
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002211static void
2212destroy_region(struct wl_resource *resource)
2213{
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002214 struct weston_region *region = wl_resource_get_user_data(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002215
2216 pixman_region32_fini(&region->region);
2217 free(region);
2218}
2219
2220static void
2221region_destroy(struct wl_client *client, struct wl_resource *resource)
2222{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04002223 wl_resource_destroy(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002224}
2225
2226static void
2227region_add(struct wl_client *client, struct wl_resource *resource,
2228 int32_t x, int32_t y, int32_t width, int32_t height)
2229{
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002230 struct weston_region *region = wl_resource_get_user_data(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002231
2232 pixman_region32_union_rect(&region->region, &region->region,
2233 x, y, width, height);
2234}
2235
2236static void
2237region_subtract(struct wl_client *client, struct wl_resource *resource,
2238 int32_t x, int32_t y, int32_t width, int32_t height)
2239{
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002240 struct weston_region *region = wl_resource_get_user_data(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002241 pixman_region32_t rect;
2242
2243 pixman_region32_init_rect(&rect, x, y, width, height);
2244 pixman_region32_subtract(&region->region, &region->region, &rect);
2245 pixman_region32_fini(&rect);
2246}
2247
2248static const struct wl_region_interface region_interface = {
2249 region_destroy,
2250 region_add,
2251 region_subtract
2252};
2253
2254static void
2255compositor_create_region(struct wl_client *client,
2256 struct wl_resource *resource, uint32_t id)
2257{
2258 struct weston_region *region;
2259
2260 region = malloc(sizeof *region);
2261 if (region == NULL) {
2262 wl_resource_post_no_memory(resource);
2263 return;
2264 }
2265
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002266 pixman_region32_init(&region->region);
2267
Jason Ekstranda85118c2013-06-27 20:17:02 -05002268 region->resource =
2269 wl_resource_create(client, &wl_region_interface, 1, id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07002270 if (region->resource == NULL) {
2271 free(region);
2272 wl_resource_post_no_memory(resource);
2273 return;
2274 }
Jason Ekstranda85118c2013-06-27 20:17:02 -05002275 wl_resource_set_implementation(region->resource, &region_interface,
2276 region, destroy_region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002277}
2278
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04002279static const struct wl_compositor_interface compositor_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002280 compositor_create_surface,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002281 compositor_create_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002282};
2283
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002284static void
Pekka Paalanene67858b2013-04-25 13:57:42 +03002285weston_subsurface_commit_from_cache(struct weston_subsurface *sub)
2286{
2287 struct weston_surface *surface = sub->surface;
Jason Ekstranda7af7042013-10-12 22:38:11 -05002288 struct weston_view *view;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002289 pixman_region32_t opaque;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002290
Alexander Larsson4ea95522013-05-22 14:41:37 +02002291 /* wl_surface.set_buffer_transform */
Alexander Larsson4ea95522013-05-22 14:41:37 +02002292 /* wl_surface.set_buffer_scale */
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02002293 /* wl_viewport.set */
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +01002294 surface->buffer_viewport = sub->cached.buffer_viewport;
Alexander Larsson4ea95522013-05-22 14:41:37 +02002295
Pekka Paalanene67858b2013-04-25 13:57:42 +03002296 /* wl_surface.attach */
Pekka Paalanen260ba382014-03-14 14:38:12 +02002297 if (sub->cached.newly_attached)
Pekka Paalanene67858b2013-04-25 13:57:42 +03002298 weston_surface_attach(surface, sub->cached.buffer_ref.buffer);
2299 weston_buffer_reference(&sub->cached.buffer_ref, NULL);
2300
Pekka Paalanene67858b2013-04-25 13:57:42 +03002301 if (surface->configure && sub->cached.newly_attached)
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06002302 surface->configure(surface, sub->cached.sx, sub->cached.sy);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002303 sub->cached.sx = 0;
2304 sub->cached.sy = 0;
2305 sub->cached.newly_attached = 0;
2306
2307 /* wl_surface.damage */
2308 pixman_region32_union(&surface->damage, &surface->damage,
2309 &sub->cached.damage);
2310 pixman_region32_intersect_rect(&surface->damage, &surface->damage,
2311 0, 0,
Jason Ekstranda7af7042013-10-12 22:38:11 -05002312 surface->width,
2313 surface->height);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002314 empty_region(&sub->cached.damage);
2315
2316 /* wl_surface.set_opaque_region */
2317 pixman_region32_init_rect(&opaque, 0, 0,
Jason Ekstranda7af7042013-10-12 22:38:11 -05002318 surface->width,
2319 surface->height);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002320 pixman_region32_intersect(&opaque,
2321 &opaque, &sub->cached.opaque);
2322
2323 if (!pixman_region32_equal(&opaque, &surface->opaque)) {
2324 pixman_region32_copy(&surface->opaque, &opaque);
Jason Ekstranda7af7042013-10-12 22:38:11 -05002325 wl_list_for_each(view, &surface->views, surface_link)
2326 weston_view_geometry_dirty(view);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002327 }
2328
2329 pixman_region32_fini(&opaque);
2330
2331 /* wl_surface.set_input_region */
2332 pixman_region32_fini(&surface->input);
2333 pixman_region32_init_rect(&surface->input, 0, 0,
Jason Ekstranda7af7042013-10-12 22:38:11 -05002334 surface->width,
2335 surface->height);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002336 pixman_region32_intersect(&surface->input,
2337 &surface->input, &sub->cached.input);
2338
2339 /* wl_surface.frame */
2340 wl_list_insert_list(&surface->frame_callback_list,
2341 &sub->cached.frame_callback_list);
2342 wl_list_init(&sub->cached.frame_callback_list);
2343
2344 weston_surface_commit_subsurface_order(surface);
2345
2346 weston_surface_schedule_repaint(surface);
2347
2348 sub->cached.has_data = 0;
2349}
2350
2351static void
2352weston_subsurface_commit_to_cache(struct weston_subsurface *sub)
2353{
2354 struct weston_surface *surface = sub->surface;
2355
2356 /*
2357 * If this commit would cause the surface to move by the
2358 * attach(dx, dy) parameters, the old damage region must be
2359 * translated to correspond to the new surface coordinate system
Hardening57388e42013-09-18 23:56:36 +02002360 * original_mode.
Pekka Paalanene67858b2013-04-25 13:57:42 +03002361 */
2362 pixman_region32_translate(&sub->cached.damage,
2363 -surface->pending.sx, -surface->pending.sy);
2364 pixman_region32_union(&sub->cached.damage, &sub->cached.damage,
2365 &surface->pending.damage);
2366 empty_region(&surface->pending.damage);
2367
2368 if (surface->pending.newly_attached) {
2369 sub->cached.newly_attached = 1;
2370 weston_buffer_reference(&sub->cached.buffer_ref,
2371 surface->pending.buffer);
2372 }
2373 sub->cached.sx += surface->pending.sx;
2374 sub->cached.sy += surface->pending.sy;
Pekka Paalanen260ba382014-03-14 14:38:12 +02002375
Pekka Paalanen3c9b8022014-03-14 14:38:13 +02002376 weston_surface_reset_pending_buffer(surface);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002377
Pekka Paalanen1fd9c0f2013-11-26 18:19:41 +01002378 sub->cached.buffer_viewport = surface->pending.buffer_viewport;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002379
2380 pixman_region32_copy(&sub->cached.opaque, &surface->pending.opaque);
2381
2382 pixman_region32_copy(&sub->cached.input, &surface->pending.input);
2383
2384 wl_list_insert_list(&sub->cached.frame_callback_list,
2385 &surface->pending.frame_callback_list);
2386 wl_list_init(&surface->pending.frame_callback_list);
2387
2388 sub->cached.has_data = 1;
2389}
2390
2391static int
2392weston_subsurface_is_synchronized(struct weston_subsurface *sub)
2393{
2394 while (sub) {
2395 if (sub->synchronized)
2396 return 1;
2397
2398 if (!sub->parent)
2399 return 0;
2400
2401 sub = weston_surface_to_subsurface(sub->parent);
2402 }
2403
2404 return 0;
2405}
2406
2407static void
2408weston_subsurface_commit(struct weston_subsurface *sub)
2409{
2410 struct weston_surface *surface = sub->surface;
2411 struct weston_subsurface *tmp;
2412
2413 /* Recursive check for effectively synchronized. */
2414 if (weston_subsurface_is_synchronized(sub)) {
2415 weston_subsurface_commit_to_cache(sub);
2416 } else {
2417 if (sub->cached.has_data) {
2418 /* flush accumulated state from cache */
2419 weston_subsurface_commit_to_cache(sub);
2420 weston_subsurface_commit_from_cache(sub);
2421 } else {
2422 weston_surface_commit(surface);
2423 }
2424
2425 wl_list_for_each(tmp, &surface->subsurface_list, parent_link) {
2426 if (tmp->surface != surface)
2427 weston_subsurface_parent_commit(tmp, 0);
2428 }
2429 }
2430}
2431
2432static void
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002433weston_subsurface_synchronized_commit(struct weston_subsurface *sub)
Pekka Paalanene67858b2013-04-25 13:57:42 +03002434{
2435 struct weston_surface *surface = sub->surface;
2436 struct weston_subsurface *tmp;
2437
Pekka Paalanene67858b2013-04-25 13:57:42 +03002438 /* From now on, commit_from_cache the whole sub-tree, regardless of
2439 * the synchronized mode of each child. This sub-surface or some
2440 * of its ancestors were synchronized, so we are synchronized
2441 * all the way down.
2442 */
2443
2444 if (sub->cached.has_data)
2445 weston_subsurface_commit_from_cache(sub);
2446
2447 wl_list_for_each(tmp, &surface->subsurface_list, parent_link) {
2448 if (tmp->surface != surface)
2449 weston_subsurface_parent_commit(tmp, 1);
2450 }
2451}
2452
2453static void
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002454weston_subsurface_parent_commit(struct weston_subsurface *sub,
2455 int parent_is_synchronized)
2456{
Jason Ekstranda7af7042013-10-12 22:38:11 -05002457 struct weston_view *view;
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002458 if (sub->position.set) {
Jason Ekstranda7af7042013-10-12 22:38:11 -05002459 wl_list_for_each(view, &sub->surface->views, surface_link)
2460 weston_view_set_position(view,
2461 sub->position.x,
2462 sub->position.y);
2463
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002464 sub->position.set = 0;
2465 }
2466
2467 if (parent_is_synchronized || sub->synchronized)
2468 weston_subsurface_synchronized_commit(sub);
2469}
2470
2471static void
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06002472subsurface_configure(struct weston_surface *surface, int32_t dx, int32_t dy)
Pekka Paalanene67858b2013-04-25 13:57:42 +03002473{
2474 struct weston_compositor *compositor = surface->compositor;
Jason Ekstranda7af7042013-10-12 22:38:11 -05002475 struct weston_view *view;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002476
Jason Ekstranda7af7042013-10-12 22:38:11 -05002477 wl_list_for_each(view, &surface->views, surface_link)
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06002478 weston_view_set_position(view,
2479 view->geometry.x + dx,
2480 view->geometry.y + dy);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002481
2482 /* No need to check parent mappedness, because if parent is not
2483 * mapped, parent is not in a visible layer, so this sub-surface
2484 * will not be drawn either.
2485 */
2486 if (!weston_surface_is_mapped(surface)) {
Pekka Paalanene67858b2013-04-25 13:57:42 +03002487 /* Cannot call weston_surface_update_transform(),
2488 * because that would call it also for the parent surface,
2489 * which might not be mapped yet. That would lead to
2490 * inconsistent state, where the window could never be
2491 * mapped.
2492 *
2493 * Instead just assing any output, to make
2494 * weston_surface_is_mapped() return true, so that when the
2495 * parent surface does get mapped, this one will get
2496 * included, too. See surface_list_add().
2497 */
2498 assert(!wl_list_empty(&compositor->output_list));
2499 surface->output = container_of(compositor->output_list.next,
2500 struct weston_output, link);
2501 }
2502}
2503
2504static struct weston_subsurface *
2505weston_surface_to_subsurface(struct weston_surface *surface)
2506{
2507 if (surface->configure == subsurface_configure)
2508 return surface->configure_private;
2509
2510 return NULL;
2511}
2512
Pekka Paalanen01388e22013-04-25 13:57:44 +03002513WL_EXPORT struct weston_surface *
2514weston_surface_get_main_surface(struct weston_surface *surface)
2515{
2516 struct weston_subsurface *sub;
2517
2518 while (surface && (sub = weston_surface_to_subsurface(surface)))
2519 surface = sub->parent;
2520
2521 return surface;
2522}
2523
Pekka Paalanene67858b2013-04-25 13:57:42 +03002524static void
2525subsurface_set_position(struct wl_client *client,
2526 struct wl_resource *resource, int32_t x, int32_t y)
2527{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002528 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002529
2530 if (!sub)
2531 return;
2532
2533 sub->position.x = x;
2534 sub->position.y = y;
2535 sub->position.set = 1;
2536}
2537
2538static struct weston_subsurface *
2539subsurface_from_surface(struct weston_surface *surface)
2540{
2541 struct weston_subsurface *sub;
2542
2543 sub = weston_surface_to_subsurface(surface);
2544 if (sub)
2545 return sub;
2546
2547 wl_list_for_each(sub, &surface->subsurface_list, parent_link)
2548 if (sub->surface == surface)
2549 return sub;
2550
2551 return NULL;
2552}
2553
2554static struct weston_subsurface *
2555subsurface_sibling_check(struct weston_subsurface *sub,
2556 struct weston_surface *surface,
2557 const char *request)
2558{
2559 struct weston_subsurface *sibling;
2560
2561 sibling = subsurface_from_surface(surface);
2562
2563 if (!sibling) {
2564 wl_resource_post_error(sub->resource,
2565 WL_SUBSURFACE_ERROR_BAD_SURFACE,
2566 "%s: wl_surface@%d is not a parent or sibling",
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002567 request, wl_resource_get_id(surface->resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002568 return NULL;
2569 }
2570
2571 if (sibling->parent != sub->parent) {
2572 wl_resource_post_error(sub->resource,
2573 WL_SUBSURFACE_ERROR_BAD_SURFACE,
2574 "%s: wl_surface@%d has a different parent",
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002575 request, wl_resource_get_id(surface->resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002576 return NULL;
2577 }
2578
2579 return sibling;
2580}
2581
2582static void
2583subsurface_place_above(struct wl_client *client,
2584 struct wl_resource *resource,
2585 struct wl_resource *sibling_resource)
2586{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002587 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002588 struct weston_surface *surface =
2589 wl_resource_get_user_data(sibling_resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002590 struct weston_subsurface *sibling;
2591
2592 if (!sub)
2593 return;
2594
2595 sibling = subsurface_sibling_check(sub, surface, "place_above");
2596 if (!sibling)
2597 return;
2598
2599 wl_list_remove(&sub->parent_link_pending);
2600 wl_list_insert(sibling->parent_link_pending.prev,
2601 &sub->parent_link_pending);
2602}
2603
2604static void
2605subsurface_place_below(struct wl_client *client,
2606 struct wl_resource *resource,
2607 struct wl_resource *sibling_resource)
2608{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002609 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002610 struct weston_surface *surface =
2611 wl_resource_get_user_data(sibling_resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002612 struct weston_subsurface *sibling;
2613
2614 if (!sub)
2615 return;
2616
2617 sibling = subsurface_sibling_check(sub, surface, "place_below");
2618 if (!sibling)
2619 return;
2620
2621 wl_list_remove(&sub->parent_link_pending);
2622 wl_list_insert(&sibling->parent_link_pending,
2623 &sub->parent_link_pending);
2624}
2625
2626static void
2627subsurface_set_sync(struct wl_client *client, struct wl_resource *resource)
2628{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002629 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002630
2631 if (sub)
2632 sub->synchronized = 1;
2633}
2634
2635static void
2636subsurface_set_desync(struct wl_client *client, struct wl_resource *resource)
2637{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002638 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002639
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002640 if (sub && sub->synchronized) {
Pekka Paalanene67858b2013-04-25 13:57:42 +03002641 sub->synchronized = 0;
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002642
2643 /* If sub became effectively desynchronized, flush. */
2644 if (!weston_subsurface_is_synchronized(sub))
2645 weston_subsurface_synchronized_commit(sub);
2646 }
Pekka Paalanene67858b2013-04-25 13:57:42 +03002647}
2648
2649static void
2650weston_subsurface_cache_init(struct weston_subsurface *sub)
2651{
2652 pixman_region32_init(&sub->cached.damage);
2653 pixman_region32_init(&sub->cached.opaque);
2654 pixman_region32_init(&sub->cached.input);
2655 wl_list_init(&sub->cached.frame_callback_list);
2656 sub->cached.buffer_ref.buffer = NULL;
2657}
2658
2659static void
2660weston_subsurface_cache_fini(struct weston_subsurface *sub)
2661{
2662 struct weston_frame_callback *cb, *tmp;
2663
2664 wl_list_for_each_safe(cb, tmp, &sub->cached.frame_callback_list, link)
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05002665 wl_resource_destroy(cb->resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002666
2667 weston_buffer_reference(&sub->cached.buffer_ref, NULL);
2668 pixman_region32_fini(&sub->cached.damage);
2669 pixman_region32_fini(&sub->cached.opaque);
2670 pixman_region32_fini(&sub->cached.input);
2671}
2672
2673static void
2674weston_subsurface_unlink_parent(struct weston_subsurface *sub)
2675{
2676 wl_list_remove(&sub->parent_link);
2677 wl_list_remove(&sub->parent_link_pending);
2678 wl_list_remove(&sub->parent_destroy_listener.link);
2679 sub->parent = NULL;
2680}
2681
2682static void
2683weston_subsurface_destroy(struct weston_subsurface *sub);
2684
2685static void
2686subsurface_handle_surface_destroy(struct wl_listener *listener, void *data)
2687{
2688 struct weston_subsurface *sub =
2689 container_of(listener, struct weston_subsurface,
2690 surface_destroy_listener);
2691 assert(data == &sub->surface->resource);
2692
2693 /* The protocol object (wl_resource) is left inert. */
2694 if (sub->resource)
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002695 wl_resource_set_user_data(sub->resource, NULL);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002696
2697 weston_subsurface_destroy(sub);
2698}
2699
2700static void
2701subsurface_handle_parent_destroy(struct wl_listener *listener, void *data)
2702{
2703 struct weston_subsurface *sub =
2704 container_of(listener, struct weston_subsurface,
2705 parent_destroy_listener);
2706 assert(data == &sub->parent->resource);
2707 assert(sub->surface != sub->parent);
2708
2709 if (weston_surface_is_mapped(sub->surface))
2710 weston_surface_unmap(sub->surface);
2711
2712 weston_subsurface_unlink_parent(sub);
2713}
2714
2715static void
2716subsurface_resource_destroy(struct wl_resource *resource)
2717{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002718 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002719
2720 if (sub)
2721 weston_subsurface_destroy(sub);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002722}
2723
2724static void
2725subsurface_destroy(struct wl_client *client, struct wl_resource *resource)
2726{
2727 wl_resource_destroy(resource);
2728}
2729
2730static void
2731weston_subsurface_link_parent(struct weston_subsurface *sub,
2732 struct weston_surface *parent)
2733{
2734 sub->parent = parent;
2735 sub->parent_destroy_listener.notify = subsurface_handle_parent_destroy;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002736 wl_signal_add(&parent->destroy_signal,
Pekka Paalanene67858b2013-04-25 13:57:42 +03002737 &sub->parent_destroy_listener);
2738
2739 wl_list_insert(&parent->subsurface_list, &sub->parent_link);
2740 wl_list_insert(&parent->subsurface_list_pending,
2741 &sub->parent_link_pending);
2742}
2743
2744static void
2745weston_subsurface_link_surface(struct weston_subsurface *sub,
2746 struct weston_surface *surface)
2747{
2748 sub->surface = surface;
2749 sub->surface_destroy_listener.notify =
2750 subsurface_handle_surface_destroy;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002751 wl_signal_add(&surface->destroy_signal,
Pekka Paalanene67858b2013-04-25 13:57:42 +03002752 &sub->surface_destroy_listener);
2753}
2754
2755static void
2756weston_subsurface_destroy(struct weston_subsurface *sub)
2757{
Jason Ekstranda7af7042013-10-12 22:38:11 -05002758 struct weston_view *view, *next;
2759
Pekka Paalanene67858b2013-04-25 13:57:42 +03002760 assert(sub->surface);
2761
2762 if (sub->resource) {
2763 assert(weston_surface_to_subsurface(sub->surface) == sub);
2764 assert(sub->parent_destroy_listener.notify ==
2765 subsurface_handle_parent_destroy);
2766
Jason Ekstranda7af7042013-10-12 22:38:11 -05002767 wl_list_for_each_safe(view, next, &sub->surface->views, surface_link)
2768 weston_view_destroy(view);
2769
Pekka Paalanene67858b2013-04-25 13:57:42 +03002770 if (sub->parent)
2771 weston_subsurface_unlink_parent(sub);
2772
2773 weston_subsurface_cache_fini(sub);
2774
2775 sub->surface->configure = NULL;
2776 sub->surface->configure_private = NULL;
2777 } else {
2778 /* the dummy weston_subsurface for the parent itself */
2779 assert(sub->parent_destroy_listener.notify == NULL);
2780 wl_list_remove(&sub->parent_link);
2781 wl_list_remove(&sub->parent_link_pending);
2782 }
2783
2784 wl_list_remove(&sub->surface_destroy_listener.link);
2785 free(sub);
2786}
2787
2788static const struct wl_subsurface_interface subsurface_implementation = {
2789 subsurface_destroy,
2790 subsurface_set_position,
2791 subsurface_place_above,
2792 subsurface_place_below,
2793 subsurface_set_sync,
2794 subsurface_set_desync
2795};
2796
2797static struct weston_subsurface *
2798weston_subsurface_create(uint32_t id, struct weston_surface *surface,
2799 struct weston_surface *parent)
2800{
2801 struct weston_subsurface *sub;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002802 struct wl_client *client = wl_resource_get_client(surface->resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002803
2804 sub = calloc(1, sizeof *sub);
2805 if (!sub)
2806 return NULL;
2807
Jason Ekstranda7af7042013-10-12 22:38:11 -05002808 wl_list_init(&sub->unused_views);
2809
Jason Ekstranda85118c2013-06-27 20:17:02 -05002810 sub->resource =
2811 wl_resource_create(client, &wl_subsurface_interface, 1, id);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002812 if (!sub->resource) {
2813 free(sub);
2814 return NULL;
2815 }
2816
Jason Ekstranda85118c2013-06-27 20:17:02 -05002817 wl_resource_set_implementation(sub->resource,
2818 &subsurface_implementation,
2819 sub, subsurface_resource_destroy);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002820 weston_subsurface_link_surface(sub, surface);
2821 weston_subsurface_link_parent(sub, parent);
2822 weston_subsurface_cache_init(sub);
2823 sub->synchronized = 1;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002824
2825 return sub;
2826}
2827
2828/* Create a dummy subsurface for having the parent itself in its
2829 * sub-surface lists. Makes stacking order manipulation easy.
2830 */
2831static struct weston_subsurface *
2832weston_subsurface_create_for_parent(struct weston_surface *parent)
2833{
2834 struct weston_subsurface *sub;
2835
2836 sub = calloc(1, sizeof *sub);
2837 if (!sub)
2838 return NULL;
2839
2840 weston_subsurface_link_surface(sub, parent);
2841 sub->parent = parent;
2842 wl_list_insert(&parent->subsurface_list, &sub->parent_link);
2843 wl_list_insert(&parent->subsurface_list_pending,
2844 &sub->parent_link_pending);
2845
2846 return sub;
2847}
2848
2849static void
2850subcompositor_get_subsurface(struct wl_client *client,
2851 struct wl_resource *resource,
2852 uint32_t id,
2853 struct wl_resource *surface_resource,
2854 struct wl_resource *parent_resource)
2855{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002856 struct weston_surface *surface =
2857 wl_resource_get_user_data(surface_resource);
2858 struct weston_surface *parent =
2859 wl_resource_get_user_data(parent_resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002860 struct weston_subsurface *sub;
2861 static const char where[] = "get_subsurface: wl_subsurface@";
2862
2863 if (surface == parent) {
2864 wl_resource_post_error(resource,
2865 WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
2866 "%s%d: wl_surface@%d cannot be its own parent",
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002867 where, id, wl_resource_get_id(surface_resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002868 return;
2869 }
2870
2871 if (weston_surface_to_subsurface(surface)) {
2872 wl_resource_post_error(resource,
2873 WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
2874 "%s%d: wl_surface@%d is already a sub-surface",
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002875 where, id, wl_resource_get_id(surface_resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002876 return;
2877 }
2878
2879 if (surface->configure) {
2880 wl_resource_post_error(resource,
2881 WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
2882 "%s%d: wl_surface@%d already has a role",
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002883 where, id, wl_resource_get_id(surface_resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002884 return;
2885 }
2886
Pekka Paalanen86c8ca02013-05-17 16:46:07 +03002887 if (weston_surface_get_main_surface(parent) == surface) {
2888 wl_resource_post_error(resource,
2889 WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
2890 "%s%d: wl_surface@%d is an ancestor of parent",
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002891 where, id, wl_resource_get_id(surface_resource));
Pekka Paalanen86c8ca02013-05-17 16:46:07 +03002892 return;
2893 }
2894
Pekka Paalanene67858b2013-04-25 13:57:42 +03002895 /* make sure the parent is in its own list */
2896 if (wl_list_empty(&parent->subsurface_list)) {
2897 if (!weston_subsurface_create_for_parent(parent)) {
2898 wl_resource_post_no_memory(resource);
2899 return;
2900 }
2901 }
2902
2903 sub = weston_subsurface_create(id, surface, parent);
2904 if (!sub) {
2905 wl_resource_post_no_memory(resource);
2906 return;
2907 }
2908
2909 surface->configure = subsurface_configure;
2910 surface->configure_private = sub;
2911}
2912
2913static void
2914subcompositor_destroy(struct wl_client *client, struct wl_resource *resource)
2915{
2916 wl_resource_destroy(resource);
2917}
2918
2919static const struct wl_subcompositor_interface subcompositor_interface = {
2920 subcompositor_destroy,
2921 subcompositor_get_subsurface
2922};
2923
2924static void
2925bind_subcompositor(struct wl_client *client,
2926 void *data, uint32_t version, uint32_t id)
2927{
2928 struct weston_compositor *compositor = data;
Jason Ekstranda85118c2013-06-27 20:17:02 -05002929 struct wl_resource *resource;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002930
Jason Ekstranda85118c2013-06-27 20:17:02 -05002931 resource =
2932 wl_resource_create(client, &wl_subcompositor_interface, 1, id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07002933 if (resource == NULL) {
2934 wl_client_post_no_memory(client);
2935 return;
2936 }
2937 wl_resource_set_implementation(resource, &subcompositor_interface,
2938 compositor, NULL);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002939}
2940
2941static void
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002942weston_compositor_dpms(struct weston_compositor *compositor,
2943 enum dpms_enum state)
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002944{
2945 struct weston_output *output;
2946
2947 wl_list_for_each(output, &compositor->output_list, link)
2948 if (output->set_dpms)
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002949 output->set_dpms(output, state);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002950}
2951
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02002952WL_EXPORT void
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002953weston_compositor_wake(struct weston_compositor *compositor)
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02002954{
Neil Roberts8b62e202013-09-30 13:14:47 +01002955 uint32_t old_state = compositor->state;
2956
2957 /* The state needs to be changed before emitting the wake
2958 * signal because that may try to schedule a repaint which
2959 * will not work if the compositor is still sleeping */
2960 compositor->state = WESTON_COMPOSITOR_ACTIVE;
2961
2962 switch (old_state) {
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002963 case WESTON_COMPOSITOR_SLEEPING:
2964 weston_compositor_dpms(compositor, WESTON_DPMS_ON);
2965 /* fall through */
2966 case WESTON_COMPOSITOR_IDLE:
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002967 case WESTON_COMPOSITOR_OFFSCREEN:
Ander Conselvan de Oliveiraa4575632013-02-21 18:35:23 +02002968 wl_signal_emit(&compositor->wake_signal, compositor);
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002969 /* fall through */
2970 default:
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002971 wl_event_source_timer_update(compositor->idle_source,
2972 compositor->idle_time * 1000);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02002973 }
2974}
2975
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002976WL_EXPORT void
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002977weston_compositor_offscreen(struct weston_compositor *compositor)
2978{
2979 switch (compositor->state) {
2980 case WESTON_COMPOSITOR_OFFSCREEN:
2981 return;
2982 case WESTON_COMPOSITOR_SLEEPING:
2983 weston_compositor_dpms(compositor, WESTON_DPMS_ON);
2984 /* fall through */
2985 default:
2986 compositor->state = WESTON_COMPOSITOR_OFFSCREEN;
2987 wl_event_source_timer_update(compositor->idle_source, 0);
2988 }
2989}
2990
2991WL_EXPORT void
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002992weston_compositor_sleep(struct weston_compositor *compositor)
2993{
2994 if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
2995 return;
2996
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002997 wl_event_source_timer_update(compositor->idle_source, 0);
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002998 compositor->state = WESTON_COMPOSITOR_SLEEPING;
2999 weston_compositor_dpms(compositor, WESTON_DPMS_OFF);
3000}
3001
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04003002static int
3003idle_handler(void *data)
3004{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003005 struct weston_compositor *compositor = data;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04003006
3007 if (compositor->idle_inhibit)
3008 return 1;
3009
Ander Conselvan de Oliveira19d10ef2013-02-21 18:35:20 +02003010 compositor->state = WESTON_COMPOSITOR_IDLE;
Ander Conselvan de Oliveiraa4575632013-02-21 18:35:23 +02003011 wl_signal_emit(&compositor->idle_signal, compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04003012
3013 return 1;
3014}
3015
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003016WL_EXPORT void
Xiong Zhang97116532013-10-23 13:58:31 +08003017weston_plane_init(struct weston_plane *plane,
3018 struct weston_compositor *ec,
3019 int32_t x, int32_t y)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003020{
3021 pixman_region32_init(&plane->damage);
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02003022 pixman_region32_init(&plane->clip);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003023 plane->x = x;
3024 plane->y = y;
Xiong Zhang97116532013-10-23 13:58:31 +08003025 plane->compositor = ec;
Ander Conselvan de Oliveira3c36bf32013-07-05 16:05:26 +03003026
3027 /* Init the link so that the call to wl_list_remove() when releasing
3028 * the plane without ever stacking doesn't lead to a crash */
3029 wl_list_init(&plane->link);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003030}
3031
3032WL_EXPORT void
3033weston_plane_release(struct weston_plane *plane)
3034{
Xiong Zhang97116532013-10-23 13:58:31 +08003035 struct weston_view *view;
3036
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003037 pixman_region32_fini(&plane->damage);
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02003038 pixman_region32_fini(&plane->clip);
Ander Conselvan de Oliveira3c36bf32013-07-05 16:05:26 +03003039
Xiong Zhang97116532013-10-23 13:58:31 +08003040 wl_list_for_each(view, &plane->compositor->view_list, link) {
3041 if (view->plane == plane)
3042 view->plane = NULL;
3043 }
3044
Ander Conselvan de Oliveira3c36bf32013-07-05 16:05:26 +03003045 wl_list_remove(&plane->link);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003046}
3047
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02003048WL_EXPORT void
3049weston_compositor_stack_plane(struct weston_compositor *ec,
3050 struct weston_plane *plane,
3051 struct weston_plane *above)
3052{
3053 if (above)
3054 wl_list_insert(above->link.prev, &plane->link);
3055 else
3056 wl_list_insert(&ec->plane_list, &plane->link);
3057}
3058
Casey Dahlin9074db52012-04-19 22:50:09 -04003059static void unbind_resource(struct wl_resource *resource)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04003060{
Jason Ekstranda0d2dde2013-06-14 10:08:01 -05003061 wl_list_remove(wl_resource_get_link(resource));
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04003062}
3063
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04003064static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04003065bind_output(struct wl_client *client,
3066 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05003067{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003068 struct weston_output *output = data;
3069 struct weston_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04003070 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05003071
Jason Ekstranda85118c2013-06-27 20:17:02 -05003072 resource = wl_resource_create(client, &wl_output_interface,
3073 MIN(version, 2), id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07003074 if (resource == NULL) {
3075 wl_client_post_no_memory(client);
3076 return;
3077 }
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04003078
Jason Ekstranda0d2dde2013-06-14 10:08:01 -05003079 wl_list_insert(&output->resource_list, wl_resource_get_link(resource));
Jason Ekstranda85118c2013-06-27 20:17:02 -05003080 wl_resource_set_implementation(resource, NULL, data, unbind_resource);
Casey Dahlin9074db52012-04-19 22:50:09 -04003081
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05003082 wl_output_send_geometry(resource,
3083 output->x,
3084 output->y,
3085 output->mm_width,
3086 output->mm_height,
3087 output->subpixel,
Kristian Høgsberg0e696472012-07-22 15:49:57 -04003088 output->make, output->model,
Kristian Høgsberg05890dc2012-08-10 10:09:20 -04003089 output->transform);
Alexander Larsson4ea95522013-05-22 14:41:37 +02003090 if (version >= 2)
3091 wl_output_send_scale(resource,
Hardeningff39efa2013-09-18 23:56:35 +02003092 output->current_scale);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04003093
3094 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05003095 wl_output_send_mode(resource,
3096 mode->flags,
3097 mode->width,
3098 mode->height,
3099 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04003100 }
Alexander Larsson4ea95522013-05-22 14:41:37 +02003101
3102 if (version >= 2)
3103 wl_output_send_done(resource);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05003104}
3105
Zhang, Xiong Ya4b54c02013-12-13 22:10:51 +02003106/* Move other outputs when one is removed so the space remains contiguos. */
3107static void
3108weston_compositor_remove_output(struct weston_compositor *compositor,
3109 struct weston_output *remove_output)
3110{
3111 struct weston_output *output;
3112 int offset = 0;
3113
3114 wl_list_for_each(output, &compositor->output_list, link) {
3115 if (output == remove_output) {
3116 offset = output->width;
3117 continue;
3118 }
3119
3120 if (offset > 0) {
3121 weston_output_move(output,
3122 output->x - offset, output->y);
3123 output->dirty = 1;
3124 }
3125 }
3126}
3127
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003128WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003129weston_output_destroy(struct weston_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003130{
Ander Conselvan de Oliveirae1e23522013-12-13 22:10:55 +02003131 output->destroying = 1;
3132
Zhang, Xiong Ya4b54c02013-12-13 22:10:51 +02003133 weston_compositor_remove_output(output->compositor, output);
Ander Conselvan de Oliveiraf749fc32013-12-13 22:10:50 +02003134 wl_list_remove(&output->link);
3135
Ander Conselvan de Oliveiraf84327a2014-01-29 18:47:51 +02003136 wl_signal_emit(&output->compositor->output_destroyed_signal, output);
Richard Hughes64ddde12013-05-01 21:52:10 +01003137 wl_signal_emit(&output->destroy_signal, output);
3138
Richard Hughesafe690c2013-05-02 10:10:04 +01003139 free(output->name);
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04003140 pixman_region32_fini(&output->region);
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +02003141 pixman_region32_fini(&output->previous_damage);
Casey Dahlin9074db52012-04-19 22:50:09 -04003142 output->compositor->output_id_pool &= ~(1 << output->id);
Benjamin Franzkeb6879402012-04-10 18:28:54 +02003143
Kristian Høgsberg919cddb2013-07-08 19:03:57 -04003144 wl_global_destroy(output->global);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003145}
3146
Scott Moreau1bad5db2012-08-18 01:04:05 -06003147static void
3148weston_output_compute_transform(struct weston_output *output)
3149{
3150 struct weston_matrix transform;
3151 int flip;
3152
3153 weston_matrix_init(&transform);
Vasily Khoruzhick1bbf3722013-01-28 22:40:28 +03003154 transform.type = WESTON_MATRIX_TRANSFORM_ROTATE;
Scott Moreau1bad5db2012-08-18 01:04:05 -06003155
3156 switch(output->transform) {
3157 case WL_OUTPUT_TRANSFORM_FLIPPED:
3158 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
3159 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
3160 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
Vasily Khoruzhick1bbf3722013-01-28 22:40:28 +03003161 transform.type |= WESTON_MATRIX_TRANSFORM_OTHER;
Scott Moreau1bad5db2012-08-18 01:04:05 -06003162 flip = -1;
3163 break;
3164 default:
3165 flip = 1;
3166 break;
3167 }
3168
3169 switch(output->transform) {
3170 case WL_OUTPUT_TRANSFORM_NORMAL:
3171 case WL_OUTPUT_TRANSFORM_FLIPPED:
3172 transform.d[0] = flip;
3173 transform.d[1] = 0;
3174 transform.d[4] = 0;
3175 transform.d[5] = 1;
3176 break;
3177 case WL_OUTPUT_TRANSFORM_90:
3178 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
3179 transform.d[0] = 0;
3180 transform.d[1] = -flip;
3181 transform.d[4] = 1;
3182 transform.d[5] = 0;
3183 break;
3184 case WL_OUTPUT_TRANSFORM_180:
3185 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
3186 transform.d[0] = -flip;
3187 transform.d[1] = 0;
3188 transform.d[4] = 0;
3189 transform.d[5] = -1;
3190 break;
3191 case WL_OUTPUT_TRANSFORM_270:
3192 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
3193 transform.d[0] = 0;
3194 transform.d[1] = flip;
3195 transform.d[4] = -1;
3196 transform.d[5] = 0;
3197 break;
3198 default:
3199 break;
3200 }
3201
3202 weston_matrix_multiply(&output->matrix, &transform);
3203}
3204
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003205WL_EXPORT void
Scott Moreauccbf29d2012-02-22 14:21:41 -07003206weston_output_update_matrix(struct weston_output *output)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003207{
Scott Moreau850ca422012-05-21 15:21:25 -06003208 float magnification;
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05003209
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003210 weston_matrix_init(&output->matrix);
3211 weston_matrix_translate(&output->matrix,
Jason Ekstrand00b84282013-10-27 22:24:59 -05003212 -(output->x + output->width / 2.0),
3213 -(output->y + output->height / 2.0), 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01003214
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003215 weston_matrix_scale(&output->matrix,
Jason Ekstrand00b84282013-10-27 22:24:59 -05003216 2.0 / output->width,
3217 -2.0 / output->height, 1);
Scott Moreau1bad5db2012-08-18 01:04:05 -06003218
Scott Moreauccbf29d2012-02-22 14:21:41 -07003219 if (output->zoom.active) {
Scott Moreaue6603982012-06-11 13:07:51 -06003220 magnification = 1 / (1 - output->zoom.spring_z.current);
Jason Ekstranda7af7042013-10-12 22:38:11 -05003221 weston_output_update_zoom(output);
Neil Roberts1e40a7e2014-04-25 13:19:37 +01003222 weston_matrix_translate(&output->matrix, -output->zoom.trans_x,
3223 output->zoom.trans_y, 0);
3224 weston_matrix_scale(&output->matrix, magnification,
3225 magnification, 1.0);
Scott Moreauccbf29d2012-02-22 14:21:41 -07003226 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003227
Neil Roberts6c3b01f2014-05-06 19:04:15 +01003228 weston_output_compute_transform(output);
3229
Scott Moreauccbf29d2012-02-22 14:21:41 -07003230 output->dirty = 0;
3231}
3232
Scott Moreau1bad5db2012-08-18 01:04:05 -06003233static void
Alexander Larsson0b135062013-05-28 16:23:36 +02003234weston_output_transform_scale_init(struct weston_output *output, uint32_t transform, uint32_t scale)
Scott Moreau1bad5db2012-08-18 01:04:05 -06003235{
3236 output->transform = transform;
3237
3238 switch (transform) {
3239 case WL_OUTPUT_TRANSFORM_90:
3240 case WL_OUTPUT_TRANSFORM_270:
3241 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
3242 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
3243 /* Swap width and height */
Hardeningff39efa2013-09-18 23:56:35 +02003244 output->width = output->current_mode->height;
3245 output->height = output->current_mode->width;
Scott Moreau1bad5db2012-08-18 01:04:05 -06003246 break;
3247 case WL_OUTPUT_TRANSFORM_NORMAL:
3248 case WL_OUTPUT_TRANSFORM_180:
3249 case WL_OUTPUT_TRANSFORM_FLIPPED:
3250 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
Hardeningff39efa2013-09-18 23:56:35 +02003251 output->width = output->current_mode->width;
3252 output->height = output->current_mode->height;
Scott Moreau1bad5db2012-08-18 01:04:05 -06003253 break;
3254 default:
3255 break;
3256 }
Scott Moreau1bad5db2012-08-18 01:04:05 -06003257
Hardening57388e42013-09-18 23:56:36 +02003258 output->native_scale = output->current_scale = scale;
Alexander Larsson0b135062013-05-28 16:23:36 +02003259 output->width /= scale;
3260 output->height /= scale;
Alexander Larsson4ea95522013-05-22 14:41:37 +02003261}
3262
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003263static void
3264weston_output_init_geometry(struct weston_output *output, int x, int y)
Scott Moreauccbf29d2012-02-22 14:21:41 -07003265{
3266 output->x = x;
3267 output->y = y;
3268
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +02003269 pixman_region32_init(&output->previous_damage);
Scott Moreauccbf29d2012-02-22 14:21:41 -07003270 pixman_region32_init_rect(&output->region, x, y,
Scott Moreau1bad5db2012-08-18 01:04:05 -06003271 output->width,
3272 output->height);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003273}
3274
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003275WL_EXPORT void
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003276weston_output_move(struct weston_output *output, int x, int y)
3277{
3278 pixman_region32_t old_region;
3279 struct wl_resource *resource;
3280
3281 output->move_x = x - output->x;
3282 output->move_y = y - output->y;
3283
3284 if (output->move_x == 0 && output->move_y == 0)
3285 return;
3286
3287 pixman_region32_init(&old_region);
3288 pixman_region32_copy(&old_region, &output->region);
3289
3290 weston_output_init_geometry(output, x, y);
3291
3292 output->dirty = 1;
3293
3294 /* Move views on this output. */
Ander Conselvan de Oliveiraa8a9baf2014-01-29 18:47:52 +02003295 wl_signal_emit(&output->compositor->output_moved_signal, output);
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003296
3297 /* Notify clients of the change for output position. */
Quanxian Wangb2c86362014-03-14 09:16:25 +08003298 wl_resource_for_each(resource, &output->resource_list) {
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003299 wl_output_send_geometry(resource,
3300 output->x,
3301 output->y,
3302 output->mm_width,
3303 output->mm_height,
3304 output->subpixel,
3305 output->make,
3306 output->model,
3307 output->transform);
Quanxian Wangb2c86362014-03-14 09:16:25 +08003308
3309 if (wl_resource_get_version(resource) >= 2)
3310 wl_output_send_done(resource);
3311 }
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003312}
3313
3314WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003315weston_output_init(struct weston_output *output, struct weston_compositor *c,
Alexander Larsson0b135062013-05-28 16:23:36 +02003316 int x, int y, int mm_width, int mm_height, uint32_t transform,
Alexander Larssonedddbd12013-05-24 13:09:43 +02003317 int32_t scale)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003318{
3319 output->compositor = c;
3320 output->x = x;
3321 output->y = y;
Alexander Larsson0b135062013-05-28 16:23:36 +02003322 output->mm_width = mm_width;
3323 output->mm_height = mm_height;
Scott Moreauccbf29d2012-02-22 14:21:41 -07003324 output->dirty = 1;
Hardeningff39efa2013-09-18 23:56:35 +02003325 output->original_scale = scale;
Scott Moreauccbf29d2012-02-22 14:21:41 -07003326
Alexander Larsson0b135062013-05-28 16:23:36 +02003327 weston_output_transform_scale_init(output, transform, scale);
Scott Moreau429490d2012-06-17 18:10:59 -06003328 weston_output_init_zoom(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003329
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003330 weston_output_init_geometry(output, x, y);
Benjamin Franzke78db8482012-04-10 18:35:33 +02003331 weston_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003332
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -04003333 wl_signal_init(&output->frame_signal);
Richard Hughes64ddde12013-05-01 21:52:10 +01003334 wl_signal_init(&output->destroy_signal);
Scott Moreau9d1b1122012-06-08 19:40:53 -06003335 wl_list_init(&output->animation_list);
Casey Dahlin9074db52012-04-19 22:50:09 -04003336 wl_list_init(&output->resource_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02003337
Casey Dahlin58ba1372012-04-19 22:50:08 -04003338 output->id = ffs(~output->compositor->output_id_pool) - 1;
3339 output->compositor->output_id_pool |= 1 << output->id;
3340
Benjamin Franzkeb6879402012-04-10 18:28:54 +02003341 output->global =
Kristian Høgsberg919cddb2013-07-08 19:03:57 -04003342 wl_global_create(c->wl_display, &wl_output_interface, 2,
3343 output, bind_output);
Richard Hughes59d5da72013-05-01 21:52:11 +01003344 wl_signal_emit(&c->output_created_signal, output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003345}
3346
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003347WL_EXPORT void
3348weston_output_transform_coordinate(struct weston_output *output,
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003349 wl_fixed_t device_x, wl_fixed_t device_y,
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003350 wl_fixed_t *x, wl_fixed_t *y)
3351{
3352 wl_fixed_t tx, ty;
3353 wl_fixed_t width, height;
Neil Robertseb5a2002014-05-01 16:13:55 +01003354 float zoom_scale, zx, zy;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003355
Hardeningff39efa2013-09-18 23:56:35 +02003356 width = wl_fixed_from_int(output->width * output->current_scale - 1);
3357 height = wl_fixed_from_int(output->height * output->current_scale - 1);
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003358
3359 switch(output->transform) {
3360 case WL_OUTPUT_TRANSFORM_NORMAL:
3361 default:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003362 tx = device_x;
3363 ty = device_y;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003364 break;
3365 case WL_OUTPUT_TRANSFORM_90:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003366 tx = device_y;
3367 ty = height - device_x;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003368 break;
3369 case WL_OUTPUT_TRANSFORM_180:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003370 tx = width - device_x;
3371 ty = height - device_y;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003372 break;
3373 case WL_OUTPUT_TRANSFORM_270:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003374 tx = width - device_y;
3375 ty = device_x;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003376 break;
3377 case WL_OUTPUT_TRANSFORM_FLIPPED:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003378 tx = width - device_x;
3379 ty = device_y;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003380 break;
3381 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003382 tx = width - device_y;
3383 ty = height - device_x;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003384 break;
3385 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003386 tx = device_x;
3387 ty = height - device_y;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003388 break;
3389 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003390 tx = device_y;
3391 ty = device_x;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003392 break;
3393 }
3394
Neil Robertseb5a2002014-05-01 16:13:55 +01003395 tx /= output->current_scale;
3396 ty /= output->current_scale;
3397
3398 if (output->zoom.active) {
3399 zoom_scale = output->zoom.spring_z.current;
3400 zx = (wl_fixed_to_double(tx) * (1.0f - zoom_scale) +
3401 output->width / 2.0f *
3402 (zoom_scale + output->zoom.trans_x));
3403 zy = (wl_fixed_to_double(ty) * (1.0f - zoom_scale) +
3404 output->height / 2.0f *
3405 (zoom_scale + output->zoom.trans_y));
3406 tx = wl_fixed_from_double(zx);
3407 ty = wl_fixed_from_double(zy);
3408 }
3409
3410 *x = tx + wl_fixed_from_int(output->x);
3411 *y = ty + wl_fixed_from_int(output->y);
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003412}
3413
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01003414static void
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003415destroy_viewport(struct wl_resource *resource)
Jonny Lamb8ae35902013-11-26 18:19:45 +01003416{
Jonny Lamb74130762013-11-26 18:19:46 +01003417 struct weston_surface *surface =
3418 wl_resource_get_user_data(resource);
3419
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003420 surface->viewport_resource = NULL;
Pekka Paalanenf0cad482014-03-14 14:38:16 +02003421 surface->pending.buffer_viewport.buffer.src_width =
3422 wl_fixed_from_int(-1);
3423 surface->pending.buffer_viewport.surface.width = -1;
Jonny Lamb8ae35902013-11-26 18:19:45 +01003424}
3425
3426static void
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003427viewport_destroy(struct wl_client *client,
3428 struct wl_resource *resource)
Jonny Lamb8ae35902013-11-26 18:19:45 +01003429{
3430 wl_resource_destroy(resource);
3431}
3432
3433static void
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003434viewport_set(struct wl_client *client,
3435 struct wl_resource *resource,
3436 wl_fixed_t src_x,
3437 wl_fixed_t src_y,
3438 wl_fixed_t src_width,
3439 wl_fixed_t src_height,
3440 int32_t dst_width,
3441 int32_t dst_height)
Jonny Lamb8ae35902013-11-26 18:19:45 +01003442{
Jonny Lamb74130762013-11-26 18:19:46 +01003443 struct weston_surface *surface =
3444 wl_resource_get_user_data(resource);
3445
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003446 assert(surface->viewport_resource != NULL);
Jonny Lamb74130762013-11-26 18:19:46 +01003447
Jonny Lamb8ae35902013-11-26 18:19:45 +01003448 if (wl_fixed_to_double(src_width) < 0 ||
3449 wl_fixed_to_double(src_height) < 0) {
3450 wl_resource_post_error(resource,
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003451 WL_VIEWPORT_ERROR_BAD_VALUE,
Jonny Lamb8ae35902013-11-26 18:19:45 +01003452 "source dimensions must be non-negative (%fx%f)",
3453 wl_fixed_to_double(src_width),
3454 wl_fixed_to_double(src_height));
3455 return;
3456 }
3457
3458 if (dst_width <= 0 || dst_height <= 0) {
3459 wl_resource_post_error(resource,
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003460 WL_VIEWPORT_ERROR_BAD_VALUE,
Jonny Lamb8ae35902013-11-26 18:19:45 +01003461 "destination dimensions must be positive (%dx%d)",
3462 dst_width, dst_height);
3463 return;
3464 }
3465
Pekka Paalanen952b6c82014-03-14 14:38:15 +02003466 surface->pending.buffer_viewport.buffer.src_x = src_x;
3467 surface->pending.buffer_viewport.buffer.src_y = src_y;
3468 surface->pending.buffer_viewport.buffer.src_width = src_width;
3469 surface->pending.buffer_viewport.buffer.src_height = src_height;
3470 surface->pending.buffer_viewport.surface.width = dst_width;
3471 surface->pending.buffer_viewport.surface.height = dst_height;
Jonny Lamb8ae35902013-11-26 18:19:45 +01003472}
3473
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003474static void
3475viewport_set_source(struct wl_client *client,
3476 struct wl_resource *resource,
3477 wl_fixed_t src_x,
3478 wl_fixed_t src_y,
3479 wl_fixed_t src_width,
3480 wl_fixed_t src_height)
3481{
3482 struct weston_surface *surface =
3483 wl_resource_get_user_data(resource);
3484
3485 assert(surface->viewport_resource != NULL);
3486
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003487 if (src_width == wl_fixed_from_int(-1) &&
3488 src_height == wl_fixed_from_int(-1)) {
3489 /* unset source size */
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003490 surface->pending.buffer_viewport.buffer.src_width =
3491 wl_fixed_from_int(-1);
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003492 return;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003493 }
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003494
3495 if (src_width <= 0 || src_height <= 0) {
3496 wl_resource_post_error(resource,
3497 WL_VIEWPORT_ERROR_BAD_VALUE,
3498 "source size must be positive (%fx%f)",
3499 wl_fixed_to_double(src_width),
3500 wl_fixed_to_double(src_height));
3501 return;
3502 }
3503
3504 surface->pending.buffer_viewport.buffer.src_x = src_x;
3505 surface->pending.buffer_viewport.buffer.src_y = src_y;
3506 surface->pending.buffer_viewport.buffer.src_width = src_width;
3507 surface->pending.buffer_viewport.buffer.src_height = src_height;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003508}
3509
3510static void
3511viewport_set_destination(struct wl_client *client,
3512 struct wl_resource *resource,
3513 int32_t dst_width,
3514 int32_t dst_height)
3515{
3516 struct weston_surface *surface =
3517 wl_resource_get_user_data(resource);
3518
3519 assert(surface->viewport_resource != NULL);
3520
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003521 if (dst_width == -1 && dst_height == -1) {
3522 /* unset destination size */
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003523 surface->pending.buffer_viewport.surface.width = -1;
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003524 return;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003525 }
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003526
3527 if (dst_width <= 0 || dst_height <= 0) {
3528 wl_resource_post_error(resource,
3529 WL_VIEWPORT_ERROR_BAD_VALUE,
3530 "destination size must be positive (%dx%d)",
3531 dst_width, dst_height);
3532 return;
3533 }
3534
3535 surface->pending.buffer_viewport.surface.width = dst_width;
3536 surface->pending.buffer_viewport.surface.height = dst_height;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003537}
3538
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003539static const struct wl_viewport_interface viewport_interface = {
3540 viewport_destroy,
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003541 viewport_set,
3542 viewport_set_source,
3543 viewport_set_destination
Jonny Lamb8ae35902013-11-26 18:19:45 +01003544};
3545
3546static void
3547scaler_destroy(struct wl_client *client,
3548 struct wl_resource *resource)
3549{
3550 wl_resource_destroy(resource);
3551}
3552
3553static void
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003554scaler_get_viewport(struct wl_client *client,
3555 struct wl_resource *scaler,
3556 uint32_t id,
3557 struct wl_resource *surface_resource)
Jonny Lamb8ae35902013-11-26 18:19:45 +01003558{
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003559 int version = wl_resource_get_version(scaler);
3560 struct weston_surface *surface =
3561 wl_resource_get_user_data(surface_resource);
Jonny Lamb8ae35902013-11-26 18:19:45 +01003562 struct wl_resource *resource;
3563
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003564 if (surface->viewport_resource) {
Jonny Lamb74130762013-11-26 18:19:46 +01003565 wl_resource_post_error(scaler,
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003566 WL_SCALER_ERROR_VIEWPORT_EXISTS,
3567 "a viewport for that surface already exists");
Jonny Lamb74130762013-11-26 18:19:46 +01003568 return;
3569 }
3570
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003571 resource = wl_resource_create(client, &wl_viewport_interface,
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003572 version, id);
Jonny Lamb8ae35902013-11-26 18:19:45 +01003573 if (resource == NULL) {
3574 wl_client_post_no_memory(client);
3575 return;
3576 }
3577
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003578 wl_resource_set_implementation(resource, &viewport_interface,
3579 surface, destroy_viewport);
Jonny Lamb74130762013-11-26 18:19:46 +01003580
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003581 surface->viewport_resource = resource;
Jonny Lamb8ae35902013-11-26 18:19:45 +01003582}
3583
3584static const struct wl_scaler_interface scaler_interface = {
3585 scaler_destroy,
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003586 scaler_get_viewport
Jonny Lamb8ae35902013-11-26 18:19:45 +01003587};
3588
3589static void
3590bind_scaler(struct wl_client *client,
3591 void *data, uint32_t version, uint32_t id)
3592{
3593 struct wl_resource *resource;
3594
3595 resource = wl_resource_create(client, &wl_scaler_interface,
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003596 MIN(version, 2), id);
Jonny Lamb8ae35902013-11-26 18:19:45 +01003597 if (resource == NULL) {
3598 wl_client_post_no_memory(client);
3599 return;
3600 }
3601
3602 wl_resource_set_implementation(resource, &scaler_interface,
3603 NULL, NULL);
3604}
3605
3606static void
Kristian Høgsberga8873122011-11-23 10:39:34 -05003607compositor_bind(struct wl_client *client,
3608 void *data, uint32_t version, uint32_t id)
3609{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003610 struct weston_compositor *compositor = data;
Jason Ekstranda85118c2013-06-27 20:17:02 -05003611 struct wl_resource *resource;
Kristian Høgsberga8873122011-11-23 10:39:34 -05003612
Jason Ekstranda85118c2013-06-27 20:17:02 -05003613 resource = wl_resource_create(client, &wl_compositor_interface,
3614 MIN(version, 3), id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07003615 if (resource == NULL) {
3616 wl_client_post_no_memory(client);
3617 return;
3618 }
3619
3620 wl_resource_set_implementation(resource, &compositor_interface,
3621 compositor, NULL);
Kristian Høgsberga8873122011-11-23 10:39:34 -05003622}
3623
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04003624static void
Martin Minarikf12c2872012-06-11 00:57:39 +02003625log_uname(void)
3626{
3627 struct utsname usys;
3628
3629 uname(&usys);
3630
3631 weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release,
3632 usys.version, usys.machine);
3633}
3634
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003635WL_EXPORT int
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +02003636weston_environment_get_fd(const char *env)
3637{
3638 char *e, *end;
3639 int fd, flags;
3640
3641 e = getenv(env);
3642 if (!e)
3643 return -1;
3644 fd = strtol(e, &end, 0);
3645 if (*end != '\0')
3646 return -1;
3647
3648 flags = fcntl(fd, F_GETFD);
3649 if (flags == -1)
3650 return -1;
3651
3652 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
3653 unsetenv(env);
3654
3655 return fd;
3656}
3657
3658WL_EXPORT int
Daniel Stonebaf43592012-06-01 11:11:10 -04003659weston_compositor_init(struct weston_compositor *ec,
3660 struct wl_display *display,
Kristian Høgsberg4172f662013-02-20 15:27:49 -05003661 int *argc, char *argv[],
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04003662 struct weston_config *config)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003663{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05003664 struct wl_event_loop *loop;
Daniel Stonee2ef43a2012-06-01 12:14:05 +01003665 struct xkb_rule_names xkb_names;
Kristian Høgsberg6a047912013-05-23 15:56:29 -04003666 struct weston_config_section *s;
Ossama Othmana50e6e42013-05-14 09:48:26 -07003667
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04003668 ec->config = config;
Kristian Høgsbergf9212892008-10-11 18:40:23 -04003669 ec->wl_display = display;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003670 wl_signal_init(&ec->destroy_signal);
Kristian Høgsbergf03a04a2014-04-06 22:04:50 -07003671 wl_signal_init(&ec->create_surface_signal);
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003672 wl_signal_init(&ec->activate_signal);
Tiago Vignattifb2adba2013-06-12 15:43:21 -03003673 wl_signal_init(&ec->transform_signal);
Tiago Vignatti1d01b012012-09-27 17:48:36 +03003674 wl_signal_init(&ec->kill_signal);
Ander Conselvan de Oliveiraa4575632013-02-21 18:35:23 +02003675 wl_signal_init(&ec->idle_signal);
3676 wl_signal_init(&ec->wake_signal);
Jan Arne Petersen42feced2012-06-21 21:52:17 +02003677 wl_signal_init(&ec->show_input_panel_signal);
3678 wl_signal_init(&ec->hide_input_panel_signal);
Jan Arne Petersen14da96b2013-04-18 16:47:28 +02003679 wl_signal_init(&ec->update_input_panel_signal);
Jan Arne Petersen674fd1d2012-11-18 19:06:42 +01003680 wl_signal_init(&ec->seat_created_signal);
Richard Hughes59d5da72013-05-01 21:52:11 +01003681 wl_signal_init(&ec->output_created_signal);
Ander Conselvan de Oliveiraf84327a2014-01-29 18:47:51 +02003682 wl_signal_init(&ec->output_destroyed_signal);
Ander Conselvan de Oliveiraa8a9baf2014-01-29 18:47:52 +02003683 wl_signal_init(&ec->output_moved_signal);
Kristian Høgsberg61741a22013-09-17 16:02:57 -07003684 wl_signal_init(&ec->session_signal);
3685 ec->session_active = 1;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003686
Casey Dahlin58ba1372012-04-19 22:50:08 -04003687 ec->output_id_pool = 0;
3688
Kristian Høgsberg919cddb2013-07-08 19:03:57 -04003689 if (!wl_global_create(display, &wl_compositor_interface, 3,
3690 ec, compositor_bind))
Kristian Høgsberga8873122011-11-23 10:39:34 -05003691 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05003692
Kristian Høgsberg919cddb2013-07-08 19:03:57 -04003693 if (!wl_global_create(display, &wl_subcompositor_interface, 1,
3694 ec, bind_subcompositor))
Pekka Paalanene67858b2013-04-25 13:57:42 +03003695 return -1;
3696
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003697 if (!wl_global_create(ec->wl_display, &wl_scaler_interface, 2,
Jonny Lamb8ae35902013-11-26 18:19:45 +01003698 ec, bind_scaler))
3699 return -1;
3700
Jason Ekstranda7af7042013-10-12 22:38:11 -05003701 wl_list_init(&ec->view_list);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02003702 wl_list_init(&ec->plane_list);
Daniel Stone725c2c32012-06-22 14:04:36 +01003703 wl_list_init(&ec->layer_list);
3704 wl_list_init(&ec->seat_list);
3705 wl_list_init(&ec->output_list);
3706 wl_list_init(&ec->key_binding_list);
Daniel Stone96d47c02013-11-19 11:37:12 +01003707 wl_list_init(&ec->modifier_binding_list);
Daniel Stone725c2c32012-06-22 14:04:36 +01003708 wl_list_init(&ec->button_binding_list);
Neil Robertsa28c6932013-10-03 16:43:04 +01003709 wl_list_init(&ec->touch_binding_list);
Daniel Stone725c2c32012-06-22 14:04:36 +01003710 wl_list_init(&ec->axis_binding_list);
Ander Conselvan de Oliveirac509d2b2012-11-08 17:20:45 +02003711 wl_list_init(&ec->debug_binding_list);
Daniel Stone725c2c32012-06-22 14:04:36 +01003712
Xiong Zhang97116532013-10-23 13:58:31 +08003713 weston_plane_init(&ec->primary_plane, ec, 0, 0);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02003714 weston_compositor_stack_plane(ec, &ec->primary_plane, NULL);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003715
Kristian Høgsberg6a047912013-05-23 15:56:29 -04003716 s = weston_config_get_section(ec->config, "keyboard", NULL, NULL);
3717 weston_config_section_get_string(s, "keymap_rules",
3718 (char **) &xkb_names.rules, NULL);
3719 weston_config_section_get_string(s, "keymap_model",
3720 (char **) &xkb_names.model, NULL);
3721 weston_config_section_get_string(s, "keymap_layout",
3722 (char **) &xkb_names.layout, NULL);
3723 weston_config_section_get_string(s, "keymap_variant",
3724 (char **) &xkb_names.variant, NULL);
3725 weston_config_section_get_string(s, "keymap_options",
3726 (char **) &xkb_names.options, NULL);
Rob Bradford382ff462013-06-24 16:52:45 +01003727
Kristian Høgsberg2f07ef62013-02-16 14:29:24 -05003728 if (weston_compositor_xkb_init(ec, &xkb_names) < 0)
3729 return -1;
Daniel Stone725c2c32012-06-22 14:04:36 +01003730
Jan Arne Petersen674fd1d2012-11-18 19:06:42 +01003731 text_backend_init(ec);
Daniel Stone725c2c32012-06-22 14:04:36 +01003732
3733 wl_data_device_manager_init(ec->wl_display);
3734
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04003735 wl_display_init_shm(display);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003736
Daniel Stone725c2c32012-06-22 14:04:36 +01003737 loop = wl_display_get_event_loop(ec->wl_display);
3738 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
3739 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
3740
3741 ec->input_loop = wl_event_loop_create();
3742
Kristian Høgsberg861a50c2012-09-05 22:02:22 -04003743 weston_layer_init(&ec->fade_layer, &ec->layer_list);
3744 weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
3745
3746 weston_compositor_schedule_repaint(ec);
3747
Daniel Stone725c2c32012-06-22 14:04:36 +01003748 return 0;
3749}
3750
Benjamin Franzkeb8263022011-08-30 11:32:47 +02003751WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003752weston_compositor_shutdown(struct weston_compositor *ec)
Matt Roper361d2ad2011-08-29 13:52:23 -07003753{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003754 struct weston_output *output, *next;
Matt Roper361d2ad2011-08-29 13:52:23 -07003755
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003756 wl_event_source_remove(ec->idle_source);
Jonas Ådahlc97af922012-03-28 22:36:09 +02003757 if (ec->input_loop_source)
3758 wl_event_source_remove(ec->input_loop_source);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003759
Matt Roper361d2ad2011-08-29 13:52:23 -07003760 /* Destroy all outputs associated with this compositor */
Tiago Vignattib303a1d2011-12-18 22:27:40 +02003761 wl_list_for_each_safe(output, next, &ec->output_list, link)
Matt Roper361d2ad2011-08-29 13:52:23 -07003762 output->destroy(output);
Pekka Paalanen4738f3b2012-01-02 15:47:07 +02003763
Ander Conselvan de Oliveira18536762013-12-20 21:07:00 +02003764 if (ec->renderer)
3765 ec->renderer->destroy(ec);
3766
Daniel Stone325fc2d2012-05-30 16:31:58 +01003767 weston_binding_list_destroy_all(&ec->key_binding_list);
3768 weston_binding_list_destroy_all(&ec->button_binding_list);
Neil Robertsa28c6932013-10-03 16:43:04 +01003769 weston_binding_list_destroy_all(&ec->touch_binding_list);
Daniel Stone325fc2d2012-05-30 16:31:58 +01003770 weston_binding_list_destroy_all(&ec->axis_binding_list);
Ander Conselvan de Oliveirac509d2b2012-11-08 17:20:45 +02003771 weston_binding_list_destroy_all(&ec->debug_binding_list);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003772
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003773 weston_plane_release(&ec->primary_plane);
3774
Jonas Ådahlc97af922012-03-28 22:36:09 +02003775 wl_event_loop_destroy(ec->input_loop);
Ossama Othmana50e6e42013-05-14 09:48:26 -07003776
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04003777 weston_config_destroy(ec->config);
Matt Roper361d2ad2011-08-29 13:52:23 -07003778}
3779
Kristian Høgsbergaf4f2aa2013-02-15 20:53:20 -05003780WL_EXPORT void
Giulio Camuffocdb4d292013-11-14 23:42:53 +01003781weston_compositor_set_default_pointer_grab(struct weston_compositor *ec,
3782 const struct weston_pointer_grab_interface *interface)
3783{
3784 struct weston_seat *seat;
3785
3786 ec->default_pointer_grab = interface;
3787 wl_list_for_each(seat, &ec->seat_list, link) {
3788 if (seat->pointer) {
3789 weston_pointer_set_default_grab(seat->pointer,
3790 interface);
3791 }
3792 }
3793}
3794
3795WL_EXPORT void
Kristian Høgsbergaf4f2aa2013-02-15 20:53:20 -05003796weston_version(int *major, int *minor, int *micro)
3797{
3798 *major = WESTON_VERSION_MAJOR;
3799 *minor = WESTON_VERSION_MINOR;
3800 *micro = WESTON_VERSION_MICRO;
3801}
3802
Pekka Paalanen7bb65102013-05-22 18:03:04 +03003803static const struct {
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +03003804 uint32_t bit; /* enum weston_capability */
Pekka Paalanen7bb65102013-05-22 18:03:04 +03003805 const char *desc;
3806} capability_strings[] = {
3807 { WESTON_CAP_ROTATION_ANY, "arbitrary surface rotation:" },
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +03003808 { WESTON_CAP_CAPTURE_YFLIP, "screen capture uses y-flip:" },
Pekka Paalanen7bb65102013-05-22 18:03:04 +03003809};
3810
3811static void
3812weston_compositor_log_capabilities(struct weston_compositor *compositor)
3813{
3814 unsigned i;
3815 int yes;
3816
3817 weston_log("Compositor capabilities:\n");
3818 for (i = 0; i < ARRAY_LENGTH(capability_strings); i++) {
3819 yes = compositor->capabilities & capability_strings[i].bit;
3820 weston_log_continue(STAMP_SPACE "%s %s\n",
3821 capability_strings[i].desc,
3822 yes ? "yes" : "no");
3823 }
3824}
3825
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003826static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003827{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003828 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003829
Martin Minarik6d118362012-06-07 18:01:59 +02003830 weston_log("caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003831 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003832
3833 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003834}
3835
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003836#ifdef HAVE_LIBUNWIND
3837
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003838static void
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003839print_backtrace(void)
3840{
3841 unw_cursor_t cursor;
3842 unw_context_t context;
3843 unw_word_t off;
3844 unw_proc_info_t pip;
3845 int ret, i = 0;
3846 char procname[256];
3847 const char *filename;
3848 Dl_info dlinfo;
3849
3850 pip.unwind_info = NULL;
3851 ret = unw_getcontext(&context);
3852 if (ret) {
3853 weston_log("unw_getcontext: %d\n", ret);
3854 return;
3855 }
3856
3857 ret = unw_init_local(&cursor, &context);
3858 if (ret) {
3859 weston_log("unw_init_local: %d\n", ret);
3860 return;
3861 }
3862
3863 ret = unw_step(&cursor);
3864 while (ret > 0) {
3865 ret = unw_get_proc_info(&cursor, &pip);
3866 if (ret) {
3867 weston_log("unw_get_proc_info: %d\n", ret);
3868 break;
3869 }
3870
3871 ret = unw_get_proc_name(&cursor, procname, 256, &off);
3872 if (ret && ret != -UNW_ENOMEM) {
3873 if (ret != -UNW_EUNSPEC)
3874 weston_log("unw_get_proc_name: %d\n", ret);
3875 procname[0] = '?';
3876 procname[1] = 0;
3877 }
3878
3879 if (dladdr((void *)(pip.start_ip + off), &dlinfo) && dlinfo.dli_fname &&
3880 *dlinfo.dli_fname)
3881 filename = dlinfo.dli_fname;
3882 else
3883 filename = "?";
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08003884
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003885 weston_log("%u: %s (%s%s+0x%x) [%p]\n", i++, filename, procname,
3886 ret == -UNW_ENOMEM ? "..." : "", (int)off, (void *)(pip.start_ip + off));
3887
3888 ret = unw_step(&cursor);
3889 if (ret < 0)
3890 weston_log("unw_step: %d\n", ret);
3891 }
3892}
3893
3894#else
3895
3896static void
3897print_backtrace(void)
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003898{
3899 void *buffer[32];
3900 int i, count;
3901 Dl_info info;
3902
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003903 count = backtrace(buffer, ARRAY_LENGTH(buffer));
3904 for (i = 0; i < count; i++) {
3905 dladdr(buffer[i], &info);
3906 weston_log(" [%016lx] %s (%s)\n",
3907 (long) buffer[i],
3908 info.dli_sname ? info.dli_sname : "--",
3909 info.dli_fname);
3910 }
3911}
3912
3913#endif
3914
3915static void
Peter Maatmane5b42e42013-03-27 22:38:53 +01003916on_caught_signal(int s, siginfo_t *siginfo, void *context)
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003917{
Peter Maatmane5b42e42013-03-27 22:38:53 +01003918 /* This signal handler will do a best-effort backtrace, and
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003919 * then call the backend restore function, which will switch
3920 * back to the vt we launched from or ungrab X etc and then
3921 * raise SIGTRAP. If we run weston under gdb from X or a
Peter Maatmane5b42e42013-03-27 22:38:53 +01003922 * different vt, and tell gdb "handle *s* nostop", this
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003923 * will allow weston to switch back to gdb on crash and then
Peter Maatmane5b42e42013-03-27 22:38:53 +01003924 * gdb will catch the crash with SIGTRAP.*/
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003925
Peter Maatmane5b42e42013-03-27 22:38:53 +01003926 weston_log("caught signal: %d\n", s);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003927
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003928 print_backtrace();
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003929
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003930 segv_compositor->restore(segv_compositor);
3931
3932 raise(SIGTRAP);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003933}
3934
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03003935WL_EXPORT void *
3936weston_load_module(const char *name, const char *entrypoint)
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003937{
3938 char path[PATH_MAX];
3939 void *module, *init;
3940
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08003941 if (name == NULL)
3942 return NULL;
3943
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003944 if (name[0] != '/')
Chad Versacebf381902012-05-23 23:42:15 -07003945 snprintf(path, sizeof path, "%s/%s", MODULEDIR, name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003946 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02003947 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003948
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003949 module = dlopen(path, RTLD_NOW | RTLD_NOLOAD);
3950 if (module) {
3951 weston_log("Module '%s' already loaded\n", path);
3952 dlclose(module);
3953 return NULL;
3954 }
3955
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003956 weston_log("Loading module '%s'\n", path);
Kristian Høgsberg1acd9f82012-07-26 11:39:26 -04003957 module = dlopen(path, RTLD_NOW);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003958 if (!module) {
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003959 weston_log("Failed to load module: %s\n", dlerror());
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003960 return NULL;
3961 }
3962
3963 init = dlsym(module, entrypoint);
3964 if (!init) {
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003965 weston_log("Failed to lookup init function: %s\n", dlerror());
Rob Bradfordc9e64ab2012-12-05 18:47:10 +00003966 dlclose(module);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003967 return NULL;
3968 }
3969
3970 return init;
3971}
3972
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003973static int
Kristian Høgsbergcb4685b2013-02-20 15:37:49 -05003974load_modules(struct weston_compositor *ec, const char *modules,
Ossama Othmana50e6e42013-05-14 09:48:26 -07003975 int *argc, char *argv[])
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003976{
3977 const char *p, *end;
3978 char buffer[256];
Kristian Høgsbergcb4685b2013-02-20 15:37:49 -05003979 int (*module_init)(struct weston_compositor *ec,
Ossama Othmana50e6e42013-05-14 09:48:26 -07003980 int *argc, char *argv[]);
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003981
3982 if (modules == NULL)
3983 return 0;
3984
3985 p = modules;
3986 while (*p) {
3987 end = strchrnul(p, ',');
3988 snprintf(buffer, sizeof buffer, "%.*s", (int) (end - p), p);
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03003989 module_init = weston_load_module(buffer, "module_init");
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003990 if (module_init)
Ossama Othmana50e6e42013-05-14 09:48:26 -07003991 module_init(ec, argc, argv);
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003992 p = end;
3993 while (*p == ',')
3994 p++;
3995
3996 }
3997
3998 return 0;
3999}
4000
Pekka Paalanen78a0b572012-06-06 16:59:44 +03004001static const char xdg_error_message[] =
Martin Minarik37032f82012-06-18 20:15:18 +02004002 "fatal: environment variable XDG_RUNTIME_DIR is not set.\n";
4003
4004static const char xdg_wrong_message[] =
4005 "fatal: environment variable XDG_RUNTIME_DIR\n"
4006 "is set to \"%s\", which is not a directory.\n";
4007
4008static const char xdg_wrong_mode_message[] =
4009 "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n"
Guillem Jover32b793c2014-01-31 20:41:21 +01004010 "correctly. Unix access mode must be 0700 (current mode is %o),\n"
4011 "and must be owned by the user (current owner is UID %d).\n";
Martin Minarik37032f82012-06-18 20:15:18 +02004012
4013static const char xdg_detail_message[] =
Pekka Paalanen78a0b572012-06-06 16:59:44 +03004014 "Refer to your distribution on how to get it, or\n"
4015 "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n"
4016 "on how to implement it.\n";
4017
Martin Minarik37032f82012-06-18 20:15:18 +02004018static void
4019verify_xdg_runtime_dir(void)
4020{
4021 char *dir = getenv("XDG_RUNTIME_DIR");
4022 struct stat s;
4023
4024 if (!dir) {
4025 weston_log(xdg_error_message);
4026 weston_log_continue(xdg_detail_message);
4027 exit(EXIT_FAILURE);
4028 }
4029
4030 if (stat(dir, &s) || !S_ISDIR(s.st_mode)) {
4031 weston_log(xdg_wrong_message, dir);
4032 weston_log_continue(xdg_detail_message);
4033 exit(EXIT_FAILURE);
4034 }
4035
4036 if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) {
4037 weston_log(xdg_wrong_mode_message,
4038 dir, s.st_mode & 0777, s.st_uid);
4039 weston_log_continue(xdg_detail_message);
4040 }
4041}
4042
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004043static int
4044usage(int error_code)
4045{
4046 fprintf(stderr,
4047 "Usage: weston [OPTIONS]\n\n"
4048 "This is weston version " VERSION ", the Wayland reference compositor.\n"
4049 "Weston supports multiple backends, and depending on which backend is in use\n"
4050 "different options will be accepted.\n\n"
4051
4052
4053 "Core options:\n\n"
Scott Moreau12245142012-08-29 15:15:58 -06004054 " --version\t\tPrint weston version\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004055 " -B, --backend=MODULE\tBackend module, one of drm-backend.so,\n"
Philipp Brüschweilere14560e2013-03-30 15:18:49 +01004056 "\t\t\t\tfbdev-backend.so, x11-backend.so or\n"
4057 "\t\t\t\twayland-backend.so\n"
Jason Ekstranda985da42013-08-22 17:28:03 -05004058 " --shell=MODULE\tShell module, defaults to desktop-shell.so\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004059 " -S, --socket=NAME\tName of socket to listen on\n"
4060 " -i, --idle-time=SECS\tIdle time in seconds\n"
Kristian Høgsberga6813d22012-09-12 12:21:01 -04004061 " --modules\t\tLoad the comma-separated list of modules\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004062 " --log==FILE\t\tLog to the given file\n"
Pekka Paalanen588bee12014-05-07 16:26:25 +03004063 " --no-config\t\tDo not read weston.ini\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004064 " -h, --help\t\tThis help message\n\n");
4065
4066 fprintf(stderr,
4067 "Options for drm-backend.so:\n\n"
4068 " --connector=ID\tBring up only this connector\n"
4069 " --seat=SEAT\t\tThe seat that weston should run on\n"
4070 " --tty=TTY\t\tThe tty to use\n"
Ander Conselvan de Oliveira23e72b82013-01-25 15:13:06 +02004071 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004072 " --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n");
4073
4074 fprintf(stderr,
Philipp Brüschweilere14560e2013-03-30 15:18:49 +01004075 "Options for fbdev-backend.so:\n\n"
4076 " --tty=TTY\t\tThe tty to use\n"
4077 " --device=DEVICE\tThe framebuffer device to use\n\n");
4078
4079 fprintf(stderr,
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004080 "Options for x11-backend.so:\n\n"
4081 " --width=WIDTH\t\tWidth of X window\n"
4082 " --height=HEIGHT\tHeight of X window\n"
4083 " --fullscreen\t\tRun in fullscreen mode\n"
Kristian Høgsbergefaca342013-01-07 15:52:44 -05004084 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004085 " --output-count=COUNT\tCreate multiple outputs\n"
4086 " --no-input\t\tDont create input devices\n\n");
4087
4088 fprintf(stderr,
4089 "Options for wayland-backend.so:\n\n"
4090 " --width=WIDTH\t\tWidth of Wayland surface\n"
4091 " --height=HEIGHT\tHeight of Wayland surface\n"
Jason Ekstrand12c6dd92013-11-07 20:13:32 -06004092 " --scale=SCALE\tScale factor of ouput\n"
Jason Ekstrand5ea04802013-11-07 20:13:33 -06004093 " --fullscreen\t\tRun in fullscreen mode\n"
Jason Ekstrandff2fd462013-10-27 22:24:58 -05004094 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
Jason Ekstrand48ce4212013-10-27 22:25:02 -05004095 " --output-count=COUNT\tCreate multiple outputs\n"
Jason Ekstrande4ca8b02014-04-02 19:53:55 -05004096 " --sprawl\t\tCreate one fullscreen output for every parent output\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004097 " --display=DISPLAY\tWayland display to connect to\n\n");
4098
Pekka Paalanene31e0532013-05-22 18:03:07 +03004099#if defined(BUILD_RPI_COMPOSITOR) && defined(HAVE_BCM_HOST)
4100 fprintf(stderr,
4101 "Options for rpi-backend.so:\n\n"
4102 " --tty=TTY\t\tThe tty to use\n"
4103 " --single-buffer\tUse single-buffered Dispmanx elements.\n"
4104 " --transform=TR\tThe output transformation, TR is one of:\n"
4105 "\tnormal 90 180 270 flipped flipped-90 flipped-180 flipped-270\n"
Tomeu Vizosoe4f7b922013-12-02 17:18:58 +01004106 " --opaque-regions\tEnable support for opaque regions, can be "
4107 "very slow without support in the GPU firmware.\n"
Pekka Paalanene31e0532013-05-22 18:03:07 +03004108 "\n");
4109#endif
4110
Hardeningc077a842013-07-08 00:51:35 +02004111#if defined(BUILD_RDP_COMPOSITOR)
4112 fprintf(stderr,
4113 "Options for rdp-backend.so:\n\n"
4114 " --width=WIDTH\t\tWidth of desktop\n"
4115 " --height=HEIGHT\tHeight of desktop\n"
Hardeningc077a842013-07-08 00:51:35 +02004116 " --env-socket=SOCKET\tUse that socket as peer connection\n"
4117 " --address=ADDR\tThe address to bind\n"
4118 " --port=PORT\tThe port to listen on\n"
Hardeningf34cd2c2014-04-02 19:54:00 -05004119 " --no-clients-resize\tThe RDP peers will be forced to the size of the desktop\n"
Hardeningc077a842013-07-08 00:51:35 +02004120 " --rdp4-key=FILE\tThe file containing the key for RDP4 encryption\n"
4121 " --rdp-tls-cert=FILE\tThe file containing the certificate for TLS encryption\n"
4122 " --rdp-tls-key=FILE\tThe file containing the private key for TLS encryption\n"
4123 "\n");
4124#endif
4125
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004126 exit(error_code);
4127}
4128
Peter Maatmane5b42e42013-03-27 22:38:53 +01004129static void
4130catch_signals(void)
4131{
4132 struct sigaction action;
4133
4134 action.sa_flags = SA_SIGINFO | SA_RESETHAND;
4135 action.sa_sigaction = on_caught_signal;
4136 sigemptyset(&action.sa_mask);
4137 sigaction(SIGSEGV, &action, NULL);
4138 sigaction(SIGABRT, &action, NULL);
4139}
4140
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004141static void
4142handle_primary_client_destroyed(struct wl_listener *listener, void *data)
4143{
4144 struct wl_client *client = data;
4145
4146 weston_log("Primary client died. Closing...\n");
4147
4148 wl_display_terminate(wl_client_get_display(client));
4149}
4150
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004151int main(int argc, char *argv[])
4152{
Pekka Paalanen3ab72692012-06-08 17:27:28 +03004153 int ret = EXIT_SUCCESS;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004154 struct wl_display *display;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05004155 struct weston_compositor *ec;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02004156 struct wl_event_source *signals[4];
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05004157 struct wl_event_loop *loop;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05004158 struct weston_compositor
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004159 *(*backend_init)(struct wl_display *display,
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04004160 int *argc, char *argv[],
4161 struct weston_config *config);
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004162 int i, fd;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004163 char *backend = NULL;
Lubomir Rintelba44c6b2013-11-15 14:18:15 +01004164 char *option_backend = NULL;
Jason Ekstranda985da42013-08-22 17:28:03 -05004165 char *shell = NULL;
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004166 char *option_shell = NULL;
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04004167 char *modules, *option_modules = NULL;
Martin Minarik19e6f262012-06-07 13:08:46 +02004168 char *log = NULL;
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004169 char *server_socket = NULL, *end;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004170 int32_t idle_time = 300;
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004171 int32_t help = 0;
Kristian Høgsbergeb00e2e2012-09-11 14:29:47 -04004172 char *socket_name = "wayland-0";
Scott Moreau12245142012-08-29 15:15:58 -06004173 int32_t version = 0;
Pekka Paalanen588bee12014-05-07 16:26:25 +03004174 int32_t noconfig = 0;
4175 struct weston_config *config = NULL;
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04004176 struct weston_config_section *section;
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004177 struct wl_client *primary_client;
4178 struct wl_listener primary_client_destroyed;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04004179
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004180 const struct weston_option core_options[] = {
Lubomir Rintelba44c6b2013-11-15 14:18:15 +01004181 { WESTON_OPTION_STRING, "backend", 'B', &option_backend },
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004182 { WESTON_OPTION_STRING, "shell", 0, &option_shell },
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004183 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
4184 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
Kristian Høgsberga6813d22012-09-12 12:21:01 -04004185 { WESTON_OPTION_STRING, "modules", 0, &option_modules },
Martin Minarik19e6f262012-06-07 13:08:46 +02004186 { WESTON_OPTION_STRING, "log", 0, &log },
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004187 { WESTON_OPTION_BOOLEAN, "help", 'h', &help },
Scott Moreau12245142012-08-29 15:15:58 -06004188 { WESTON_OPTION_BOOLEAN, "version", 0, &version },
Pekka Paalanen588bee12014-05-07 16:26:25 +03004189 { WESTON_OPTION_BOOLEAN, "no-config", 0, &noconfig },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04004190 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05004191
Kristian Høgsberg4172f662013-02-20 15:27:49 -05004192 parse_options(core_options, ARRAY_LENGTH(core_options), &argc, argv);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004193
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004194 if (help)
4195 usage(EXIT_SUCCESS);
4196
Scott Moreau12245142012-08-29 15:15:58 -06004197 if (version) {
4198 printf(PACKAGE_STRING "\n");
4199 return EXIT_SUCCESS;
4200 }
4201
Rafal Mielniczuk6e0a7d82012-06-09 15:10:28 +02004202 weston_log_file_open(log);
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004203
Pekka Paalanenbce4c2b2012-06-11 14:04:21 +03004204 weston_log("%s\n"
4205 STAMP_SPACE "%s\n"
4206 STAMP_SPACE "Bug reports to: %s\n"
4207 STAMP_SPACE "Build: %s\n",
4208 PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT,
Kristian Høgsberg23cf9eb2012-06-11 12:06:30 -04004209 BUILD_ID);
Pekka Paalanen7f4d1a32012-06-11 14:06:03 +03004210 log_uname();
Kristian Høgsberga411c8b2012-06-08 16:16:52 -04004211
Martin Minarik37032f82012-06-18 20:15:18 +02004212 verify_xdg_runtime_dir();
4213
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004214 display = wl_display_create();
4215
Tiago Vignatti2116b892011-08-08 05:52:59 -07004216 loop = wl_display_get_event_loop(display);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02004217 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
4218 display);
4219 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
4220 display);
4221 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
4222 display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07004223
4224 wl_list_init(&child_process_list);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02004225 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
4226 NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05004227
Pekka Paalanen588bee12014-05-07 16:26:25 +03004228 if (noconfig == 0)
4229 config = weston_config_parse("weston.ini");
Lubomir Rintelba44c6b2013-11-15 14:18:15 +01004230 if (config != NULL) {
4231 weston_log("Using config file '%s'\n",
4232 weston_config_get_full_path(config));
4233 } else {
4234 weston_log("Starting with no config file.\n");
4235 }
4236 section = weston_config_get_section(config, "core", NULL, NULL);
4237
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004238 if (option_backend)
4239 backend = strdup(option_backend);
4240 else
4241 weston_config_section_get_string(section, "backend", &backend,
4242 NULL);
4243
Kristian Høgsberg1c562182011-05-02 22:09:20 -04004244 if (!backend) {
Jason Ekstrandcf40a132014-04-02 19:53:56 -05004245 if (getenv("WAYLAND_DISPLAY") || getenv("WAYLAND_SOCKET"))
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004246 backend = strdup("wayland-backend.so");
Kristian Høgsberg1c562182011-05-02 22:09:20 -04004247 else if (getenv("DISPLAY"))
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004248 backend = strdup("x11-backend.so");
Kristian Høgsberg1c562182011-05-02 22:09:20 -04004249 else
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004250 backend = strdup(WESTON_NATIVE_BACKEND);
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04004251 }
4252
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03004253 backend_init = weston_load_module(backend, "backend_init");
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004254 free(backend);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04004255 if (!backend_init)
4256 exit(EXIT_FAILURE);
Kristian Høgsberga9410222011-01-14 17:22:35 -05004257
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04004258 ec = backend_init(display, &argc, argv, config);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05004259 if (ec == NULL) {
Pekka Paalanen33616392012-07-30 16:56:57 +03004260 weston_log("fatal: failed to create compositor\n");
Kristian Høgsberg841883b2008-12-05 11:19:56 -05004261 exit(EXIT_FAILURE);
4262 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04004263
Peter Maatmane5b42e42013-03-27 22:38:53 +01004264 catch_signals();
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04004265 segv_compositor = ec;
4266
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004267 ec->idle_time = idle_time;
Giulio Camuffocdb4d292013-11-14 23:42:53 +01004268 ec->default_pointer_grab = NULL;
Pekka Paalanen7296e792011-12-07 16:22:00 +02004269
Kristian Høgsbergeb00e2e2012-09-11 14:29:47 -04004270 setenv("WAYLAND_DISPLAY", socket_name, 1);
4271
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004272 if (option_shell)
4273 shell = strdup(option_shell);
4274 else
Jason Ekstranda985da42013-08-22 17:28:03 -05004275 weston_config_section_get_string(section, "shell", &shell,
4276 "desktop-shell.so");
Jason Ekstranda985da42013-08-22 17:28:03 -05004277
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004278 if (load_modules(ec, shell, &argc, argv) < 0) {
4279 free(shell);
Pekka Paalanen33616392012-07-30 16:56:57 +03004280 goto out;
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004281 }
4282 free(shell);
4283
4284 weston_config_section_get_string(section, "modules", &modules, "");
4285 if (load_modules(ec, modules, &argc, argv) < 0) {
4286 free(modules);
4287 goto out;
4288 }
4289 free(modules);
4290
Ossama Othmana50e6e42013-05-14 09:48:26 -07004291 if (load_modules(ec, option_modules, &argc, argv) < 0)
Pekka Paalanen33616392012-07-30 16:56:57 +03004292 goto out;
Tiago Vignattie4faa2a2012-04-16 17:31:44 +03004293
Kristian Høgsbergcb4685b2013-02-20 15:37:49 -05004294 for (i = 1; i < argc; i++)
4295 weston_log("fatal: unhandled option: %s\n", argv[i]);
4296 if (argc > 1) {
4297 ret = EXIT_FAILURE;
4298 goto out;
4299 }
4300
Pekka Paalanen7bb65102013-05-22 18:03:04 +03004301 weston_compositor_log_capabilities(ec);
4302
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004303 server_socket = getenv("WAYLAND_SERVER_SOCKET");
4304 if (server_socket) {
4305 weston_log("Running with single client\n");
4306 fd = strtol(server_socket, &end, 0);
4307 if (*end != '\0')
4308 fd = -1;
4309 } else {
4310 fd = -1;
4311 }
4312
4313 if (fd != -1) {
4314 primary_client = wl_client_create(display, fd);
4315 if (!primary_client) {
4316 weston_log("fatal: failed to add client: %m\n");
4317 ret = EXIT_FAILURE;
4318 goto out;
4319 }
4320 primary_client_destroyed.notify =
4321 handle_primary_client_destroyed;
4322 wl_client_add_destroy_listener(primary_client,
4323 &primary_client_destroyed);
4324 } else {
4325 if (wl_display_add_socket(display, socket_name)) {
4326 weston_log("fatal: failed to add socket: %m\n");
4327 ret = EXIT_FAILURE;
4328 goto out;
4329 }
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004330 }
4331
Pekka Paalanenc0444e32012-01-05 16:28:21 +02004332 weston_compositor_wake(ec);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004333
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04004334 wl_display_run(display);
4335
4336 out:
Pekka Paalanen0135abe2012-01-03 10:01:20 +02004337 /* prevent further rendering while shutting down */
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01004338 ec->state = WESTON_COMPOSITOR_OFFSCREEN;
Pekka Paalanen0135abe2012-01-03 10:01:20 +02004339
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04004340 wl_signal_emit(&ec->destroy_signal, ec);
Pekka Paalanen3c647232011-12-22 13:43:43 +02004341
Pekka Paalanen51c769f2012-01-02 16:03:26 +02004342 for (i = ARRAY_LENGTH(signals); i;)
4343 wl_event_source_remove(signals[--i]);
4344
Daniel Stone855028f2012-05-01 20:37:10 +01004345 weston_compositor_xkb_destroy(ec);
4346
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05004347 ec->destroy(ec);
Tiago Vignatti9e2be082011-12-19 00:04:46 +02004348 wl_display_destroy(display);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05004349
Martin Minarik19e6f262012-06-07 13:08:46 +02004350 weston_log_file_close();
4351
Pekka Paalanen3ab72692012-06-08 17:27:28 +03004352 return ret;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04004353}