blob: 17fce8d1dae4b6344bb391a947f178c091861ea9 [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 Paalanen0cbd3b52012-10-10 12:49:28 +0300323region_init_infinite(pixman_region32_t *region)
324{
325 pixman_region32_init_rect(region, INT32_MIN, INT32_MIN,
326 UINT32_MAX, UINT32_MAX);
327}
328
Pekka Paalanene67858b2013-04-25 13:57:42 +0300329static struct weston_subsurface *
330weston_surface_to_subsurface(struct weston_surface *surface);
331
Jason Ekstranda7af7042013-10-12 22:38:11 -0500332WL_EXPORT struct weston_view *
333weston_view_create(struct weston_surface *surface)
334{
335 struct weston_view *view;
336
337 view = calloc(1, sizeof *view);
338 if (view == NULL)
339 return NULL;
340
341 view->surface = surface;
342
Jason Ekstranda7af7042013-10-12 22:38:11 -0500343 /* Assign to surface */
344 wl_list_insert(&surface->views, &view->surface_link);
345
346 wl_signal_init(&view->destroy_signal);
347 wl_list_init(&view->link);
348 wl_list_init(&view->layer_link);
349
Xiong Zhang97116532013-10-23 13:58:31 +0800350 view->plane = NULL;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500351
352 pixman_region32_init(&view->clip);
353
354 view->alpha = 1.0;
355 pixman_region32_init(&view->transform.opaque);
356
357 wl_list_init(&view->geometry.transformation_list);
358 wl_list_insert(&view->geometry.transformation_list,
359 &view->transform.position.link);
360 weston_matrix_init(&view->transform.position.matrix);
361 wl_list_init(&view->geometry.child_list);
362 pixman_region32_init(&view->transform.boundingbox);
363 view->transform.dirty = 1;
364
365 view->output = NULL;
366
367 return view;
368}
369
Jason Ekstrand108865d2014-06-26 10:04:49 -0700370struct weston_frame_callback {
371 struct wl_resource *resource;
372 struct wl_list link;
373};
374
Jason Ekstrand7b982072014-05-20 14:33:03 -0500375static void
376surface_state_handle_buffer_destroy(struct wl_listener *listener, void *data)
377{
378 struct weston_surface_state *state =
379 container_of(listener, struct weston_surface_state,
380 buffer_destroy_listener);
381
382 state->buffer = NULL;
383}
384
385static void
386weston_surface_state_init(struct weston_surface_state *state)
387{
388 state->newly_attached = 0;
389 state->buffer = NULL;
390 state->buffer_destroy_listener.notify =
391 surface_state_handle_buffer_destroy;
392 state->sx = 0;
393 state->sy = 0;
394
395 pixman_region32_init(&state->damage);
396 pixman_region32_init(&state->opaque);
397 region_init_infinite(&state->input);
398
399 wl_list_init(&state->frame_callback_list);
400
401 state->buffer_viewport.buffer.transform = WL_OUTPUT_TRANSFORM_NORMAL;
402 state->buffer_viewport.buffer.scale = 1;
403 state->buffer_viewport.buffer.src_width = wl_fixed_from_int(-1);
404 state->buffer_viewport.surface.width = -1;
405 state->buffer_viewport.changed = 0;
406}
407
408static void
409weston_surface_state_fini(struct weston_surface_state *state)
410{
411 struct weston_frame_callback *cb, *next;
412
413 wl_list_for_each_safe(cb, next,
414 &state->frame_callback_list, link)
415 wl_resource_destroy(cb->resource);
416
417 pixman_region32_fini(&state->input);
418 pixman_region32_fini(&state->opaque);
419 pixman_region32_fini(&state->damage);
420
421 if (state->buffer)
422 wl_list_remove(&state->buffer_destroy_listener.link);
423 state->buffer = NULL;
424}
425
426static void
427weston_surface_state_set_buffer(struct weston_surface_state *state,
428 struct weston_buffer *buffer)
429{
430 if (state->buffer == buffer)
431 return;
432
433 if (state->buffer)
434 wl_list_remove(&state->buffer_destroy_listener.link);
435 state->buffer = buffer;
436 if (state->buffer)
437 wl_signal_add(&state->buffer->destroy_signal,
438 &state->buffer_destroy_listener);
439}
440
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500441WL_EXPORT struct weston_surface *
Kristian Høgsberg18c93002012-01-27 11:58:31 -0500442weston_surface_create(struct weston_compositor *compositor)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500443{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -0500444 struct weston_surface *surface;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400445
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200446 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400447 if (surface == NULL)
448 return NULL;
449
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500450 wl_signal_init(&surface->destroy_signal);
451
452 surface->resource = NULL;
Kristian Høgsberg48891542012-02-23 17:38:33 -0500453
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500454 surface->compositor = compositor;
Giulio Camuffo13b85bd2013-08-13 23:10:14 +0200455 surface->ref_count = 1;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400456
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200457 surface->buffer_viewport.buffer.transform = WL_OUTPUT_TRANSFORM_NORMAL;
458 surface->buffer_viewport.buffer.scale = 1;
Pekka Paalanenf0cad482014-03-14 14:38:16 +0200459 surface->buffer_viewport.buffer.src_width = wl_fixed_from_int(-1);
460 surface->buffer_viewport.surface.width = -1;
Jason Ekstrand7b982072014-05-20 14:33:03 -0500461
462 weston_surface_state_init(&surface->pending);
463
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400464 surface->output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200465
Pekka Paalanenb0420ae2014-01-08 15:39:17 +0200466 surface->viewport_resource = NULL;
Jonny Lamb74130762013-11-26 18:19:46 +0100467
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400468 pixman_region32_init(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500469 pixman_region32_init(&surface->opaque);
Pekka Paalanen8ec4ab62012-10-10 12:49:32 +0300470 region_init_infinite(&surface->input);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400471
Jason Ekstranda7af7042013-10-12 22:38:11 -0500472 wl_list_init(&surface->views);
473
474 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500475
Pekka Paalanene67858b2013-04-25 13:57:42 +0300476 wl_list_init(&surface->subsurface_list);
477 wl_list_init(&surface->subsurface_list_pending);
478
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400479 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500480}
481
Alex Wu8811bf92012-02-28 18:07:54 +0800482WL_EXPORT void
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500483weston_surface_set_color(struct weston_surface *surface,
John Kåre Alsaker490d02a2012-09-30 02:57:21 +0200484 float red, float green, float blue, float alpha)
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500485{
John Kåre Alsaker878f4492012-11-13 19:10:23 +0100486 surface->compositor->renderer->surface_set_color(surface, red, green, blue, alpha);
Kristian Høgsbergbbeefb02012-01-26 10:00:23 -0500487}
488
Kristian Høgsberge4c1a5f2012-06-18 13:17:32 -0400489WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500490weston_view_to_global_float(struct weston_view *view,
491 float sx, float sy, float *x, float *y)
Pekka Paalanenece8a012012-02-08 15:23:15 +0200492{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500493 if (view->transform.enabled) {
Pekka Paalanenece8a012012-02-08 15:23:15 +0200494 struct weston_vector v = { { sx, sy, 0.0f, 1.0f } };
495
Jason Ekstranda7af7042013-10-12 22:38:11 -0500496 weston_matrix_transform(&view->transform.matrix, &v);
Pekka Paalanenece8a012012-02-08 15:23:15 +0200497
498 if (fabsf(v.f[3]) < 1e-6) {
Martin Minarik6d118362012-06-07 18:01:59 +0200499 weston_log("warning: numerical instability in "
Scott Moreau088c62e2013-02-11 04:45:38 -0700500 "%s(), divisor = %g\n", __func__,
Pekka Paalanenece8a012012-02-08 15:23:15 +0200501 v.f[3]);
502 *x = 0;
503 *y = 0;
504 return;
505 }
506
507 *x = v.f[0] / v.f[3];
508 *y = v.f[1] / v.f[3];
509 } else {
Jason Ekstranda7af7042013-10-12 22:38:11 -0500510 *x = sx + view->geometry.x;
511 *y = sy + view->geometry.y;
Pekka Paalanenece8a012012-02-08 15:23:15 +0200512 }
513}
514
Kristian Høgsbergd8bf90c2012-02-23 23:03:14 -0500515WL_EXPORT void
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200516weston_transformed_coord(int width, int height,
517 enum wl_output_transform transform,
Alexander Larssonedddbd12013-05-24 13:09:43 +0200518 int32_t scale,
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200519 float sx, float sy, float *bx, float *by)
520{
521 switch (transform) {
522 case WL_OUTPUT_TRANSFORM_NORMAL:
523 default:
524 *bx = sx;
525 *by = sy;
526 break;
527 case WL_OUTPUT_TRANSFORM_FLIPPED:
528 *bx = width - sx;
529 *by = sy;
530 break;
531 case WL_OUTPUT_TRANSFORM_90:
532 *bx = height - sy;
533 *by = sx;
534 break;
535 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
536 *bx = height - sy;
537 *by = width - sx;
538 break;
539 case WL_OUTPUT_TRANSFORM_180:
540 *bx = width - sx;
541 *by = height - sy;
542 break;
543 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
544 *bx = sx;
545 *by = height - sy;
546 break;
547 case WL_OUTPUT_TRANSFORM_270:
548 *bx = sy;
549 *by = width - sx;
550 break;
551 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
552 *bx = sy;
553 *by = sx;
554 break;
555 }
Alexander Larsson4ea95522013-05-22 14:41:37 +0200556
557 *bx *= scale;
558 *by *= scale;
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200559}
560
561WL_EXPORT pixman_box32_t
562weston_transformed_rect(int width, int height,
563 enum wl_output_transform transform,
Alexander Larssonedddbd12013-05-24 13:09:43 +0200564 int32_t scale,
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200565 pixman_box32_t rect)
566{
567 float x1, x2, y1, y2;
568
569 pixman_box32_t ret;
570
Alexander Larsson4ea95522013-05-22 14:41:37 +0200571 weston_transformed_coord(width, height, transform, scale,
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200572 rect.x1, rect.y1, &x1, &y1);
Alexander Larsson4ea95522013-05-22 14:41:37 +0200573 weston_transformed_coord(width, height, transform, scale,
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +0200574 rect.x2, rect.y2, &x2, &y2);
575
576 if (x1 <= x2) {
577 ret.x1 = x1;
578 ret.x2 = x2;
579 } else {
580 ret.x1 = x2;
581 ret.x2 = x1;
582 }
583
584 if (y1 <= y2) {
585 ret.y1 = y1;
586 ret.y2 = y2;
587 } else {
588 ret.y1 = y2;
589 ret.y2 = y1;
590 }
591
592 return ret;
593}
594
595WL_EXPORT void
Jason Ekstrand33ff6362013-10-27 22:25:01 -0500596weston_transformed_region(int width, int height,
597 enum wl_output_transform transform,
598 int32_t scale,
599 pixman_region32_t *src, pixman_region32_t *dest)
600{
601 pixman_box32_t *src_rects, *dest_rects;
602 int nrects, i;
603
604 if (transform == WL_OUTPUT_TRANSFORM_NORMAL && scale == 1) {
605 if (src != dest)
606 pixman_region32_copy(dest, src);
607 return;
608 }
609
610 src_rects = pixman_region32_rectangles(src, &nrects);
611 dest_rects = malloc(nrects * sizeof(*dest_rects));
612 if (!dest_rects)
613 return;
614
615 if (transform == WL_OUTPUT_TRANSFORM_NORMAL) {
616 memcpy(dest_rects, src_rects, nrects * sizeof(*dest_rects));
617 } else {
618 for (i = 0; i < nrects; i++) {
619 switch (transform) {
620 default:
621 case WL_OUTPUT_TRANSFORM_NORMAL:
622 dest_rects[i].x1 = src_rects[i].x1;
623 dest_rects[i].y1 = src_rects[i].y1;
624 dest_rects[i].x2 = src_rects[i].x2;
625 dest_rects[i].y2 = src_rects[i].y2;
626 break;
627 case WL_OUTPUT_TRANSFORM_90:
628 dest_rects[i].x1 = height - src_rects[i].y2;
629 dest_rects[i].y1 = src_rects[i].x1;
630 dest_rects[i].x2 = height - src_rects[i].y1;
631 dest_rects[i].y2 = src_rects[i].x2;
632 break;
633 case WL_OUTPUT_TRANSFORM_180:
634 dest_rects[i].x1 = width - src_rects[i].x2;
635 dest_rects[i].y1 = height - src_rects[i].y2;
636 dest_rects[i].x2 = width - src_rects[i].x1;
637 dest_rects[i].y2 = height - src_rects[i].y1;
638 break;
639 case WL_OUTPUT_TRANSFORM_270:
640 dest_rects[i].x1 = src_rects[i].y1;
641 dest_rects[i].y1 = width - src_rects[i].x2;
642 dest_rects[i].x2 = src_rects[i].y2;
643 dest_rects[i].y2 = width - src_rects[i].x1;
644 break;
645 case WL_OUTPUT_TRANSFORM_FLIPPED:
646 dest_rects[i].x1 = width - src_rects[i].x2;
647 dest_rects[i].y1 = src_rects[i].y1;
648 dest_rects[i].x2 = width - src_rects[i].x1;
649 dest_rects[i].y2 = src_rects[i].y2;
650 break;
651 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
652 dest_rects[i].x1 = height - src_rects[i].y2;
653 dest_rects[i].y1 = width - src_rects[i].x2;
654 dest_rects[i].x2 = height - src_rects[i].y1;
655 dest_rects[i].y2 = width - src_rects[i].x1;
656 break;
657 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
658 dest_rects[i].x1 = src_rects[i].x1;
659 dest_rects[i].y1 = height - src_rects[i].y2;
660 dest_rects[i].x2 = src_rects[i].x2;
661 dest_rects[i].y2 = height - src_rects[i].y1;
662 break;
663 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
664 dest_rects[i].x1 = src_rects[i].y1;
665 dest_rects[i].y1 = src_rects[i].x1;
666 dest_rects[i].x2 = src_rects[i].y2;
667 dest_rects[i].y2 = src_rects[i].x2;
668 break;
669 }
670 }
671 }
672
673 if (scale != 1) {
674 for (i = 0; i < nrects; i++) {
675 dest_rects[i].x1 *= scale;
676 dest_rects[i].x2 *= scale;
677 dest_rects[i].y1 *= scale;
678 dest_rects[i].y2 *= scale;
679 }
680 }
681
682 pixman_region32_clear(dest);
683 pixman_region32_init_rects(dest, dest_rects, nrects);
684 free(dest_rects);
685}
686
Jonny Lamb74130762013-11-26 18:19:46 +0100687static void
688scaler_surface_to_buffer(struct weston_surface *surface,
689 float sx, float sy, float *bx, float *by)
690{
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200691 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200692 double src_width, src_height;
693 double src_x, src_y;
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200694
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200695 if (vp->buffer.src_width == wl_fixed_from_int(-1)) {
696 if (vp->surface.width == -1) {
697 *bx = sx;
698 *by = sy;
699 return;
700 }
Jonny Lamb74130762013-11-26 18:19:46 +0100701
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200702 src_x = 0.0;
703 src_y = 0.0;
704 src_width = surface->width_from_buffer;
705 src_height = surface->height_from_buffer;
Jonny Lamb74130762013-11-26 18:19:46 +0100706 } else {
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200707 src_x = wl_fixed_to_double(vp->buffer.src_x);
708 src_y = wl_fixed_to_double(vp->buffer.src_y);
709 src_width = wl_fixed_to_double(vp->buffer.src_width);
710 src_height = wl_fixed_to_double(vp->buffer.src_height);
Jonny Lamb74130762013-11-26 18:19:46 +0100711 }
Pekka Paalanen0b4c5352014-03-14 14:38:17 +0200712
713 *bx = sx * src_width / surface->width + src_x;
714 *by = sy * src_height / surface->height + src_y;
Jonny Lamb74130762013-11-26 18:19:46 +0100715}
716
Jason Ekstrand33ff6362013-10-27 22:25:01 -0500717WL_EXPORT void
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200718weston_surface_to_buffer_float(struct weston_surface *surface,
719 float sx, float sy, float *bx, float *by)
720{
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200721 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
722
Jonny Lamb74130762013-11-26 18:19:46 +0100723 /* first transform coordinates if the scaler is set */
724 scaler_surface_to_buffer(surface, sx, sy, bx, by);
725
Jason Ekstrandd0cebc32014-04-21 20:56:46 -0500726 weston_transformed_coord(surface->width_from_buffer,
727 surface->height_from_buffer,
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200728 vp->buffer.transform, vp->buffer.scale,
Jonny Lamb74130762013-11-26 18:19:46 +0100729 *bx, *by, bx, by);
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200730}
731
Alexander Larsson4ea95522013-05-22 14:41:37 +0200732WL_EXPORT void
733weston_surface_to_buffer(struct weston_surface *surface,
734 int sx, int sy, int *bx, int *by)
735{
736 float bxf, byf;
737
Jonny Lamb74130762013-11-26 18:19:46 +0100738 weston_surface_to_buffer_float(surface,
739 sx, sy, &bxf, &byf);
740
Alexander Larsson4ea95522013-05-22 14:41:37 +0200741 *bx = floorf(bxf);
742 *by = floorf(byf);
743}
744
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200745WL_EXPORT pixman_box32_t
746weston_surface_to_buffer_rect(struct weston_surface *surface,
747 pixman_box32_t rect)
748{
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200749 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
Jonny Lamb74130762013-11-26 18:19:46 +0100750 float xf, yf;
751
752 /* first transform box coordinates if the scaler is set */
753 scaler_surface_to_buffer(surface, rect.x1, rect.y1, &xf, &yf);
754 rect.x1 = floorf(xf);
755 rect.y1 = floorf(yf);
756
757 scaler_surface_to_buffer(surface, rect.x2, rect.y2, &xf, &yf);
758 rect.x2 = floorf(xf);
759 rect.y2 = floorf(yf);
760
Jason Ekstrandd0cebc32014-04-21 20:56:46 -0500761 return weston_transformed_rect(surface->width_from_buffer,
762 surface->height_from_buffer,
Pekka Paalanen952b6c82014-03-14 14:38:15 +0200763 vp->buffer.transform, vp->buffer.scale,
Alexander Larsson4ea95522013-05-22 14:41:37 +0200764 rect);
Ander Conselvan de Oliveira0396ba22012-11-28 17:10:26 +0200765}
766
767WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500768weston_view_move_to_plane(struct weston_view *view,
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400769 struct weston_plane *plane)
770{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500771 if (view->plane == plane)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400772 return;
773
Jason Ekstranda7af7042013-10-12 22:38:11 -0500774 weston_view_damage_below(view);
775 view->plane = plane;
776 weston_surface_damage(view->surface);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -0400777}
778
779WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500780weston_view_damage_below(struct weston_view *view)
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200781{
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500782 pixman_region32_t damage;
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200783
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500784 pixman_region32_init(&damage);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500785 pixman_region32_subtract(&damage, &view->transform.boundingbox,
786 &view->clip);
Xiong Zhang97116532013-10-23 13:58:31 +0800787 if (view->plane)
788 pixman_region32_union(&view->plane->damage,
789 &view->plane->damage, &damage);
Kristian Høgsberg1e832122012-02-28 22:47:14 -0500790 pixman_region32_fini(&damage);
Kristian Høgsberga3a784a2013-11-13 21:33:43 -0800791 weston_view_schedule_repaint(view);
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200792}
793
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400794static void
795weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask)
796{
797 uint32_t different = es->output_mask ^ mask;
798 uint32_t entered = mask & different;
799 uint32_t left = es->output_mask & different;
800 struct weston_output *output;
801 struct wl_resource *resource = NULL;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500802 struct wl_client *client;
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400803
804 es->output_mask = mask;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500805 if (es->resource == NULL)
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400806 return;
807 if (different == 0)
808 return;
809
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500810 client = wl_resource_get_client(es->resource);
811
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400812 wl_list_for_each(output, &es->compositor->output_list, link) {
813 if (1 << output->id & different)
814 resource =
Jason Ekstranda0d2dde2013-06-14 10:08:01 -0500815 wl_resource_find_for_client(&output->resource_list,
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400816 client);
817 if (resource == NULL)
818 continue;
819 if (1 << output->id & entered)
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500820 wl_surface_send_enter(es->resource, resource);
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400821 if (1 << output->id & left)
Jason Ekstrand26ed73c2013-06-06 22:34:41 -0500822 wl_surface_send_leave(es->resource, resource);
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400823 }
824}
825
Zhang, Xiong Yf3012412013-12-13 22:10:53 +0200826
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400827static void
828weston_surface_assign_output(struct weston_surface *es)
829{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500830 struct weston_output *new_output;
831 struct weston_view *view;
832 pixman_region32_t region;
833 uint32_t max, area, mask;
834 pixman_box32_t *e;
835
836 new_output = NULL;
837 max = 0;
838 mask = 0;
839 pixman_region32_init(&region);
840 wl_list_for_each(view, &es->views, surface_link) {
841 if (!view->output)
842 continue;
843
844 pixman_region32_intersect(&region, &view->transform.boundingbox,
845 &view->output->region);
846
847 e = pixman_region32_extents(&region);
848 area = (e->x2 - e->x1) * (e->y2 - e->y1);
849
850 mask |= view->output_mask;
851
852 if (area >= max) {
853 new_output = view->output;
854 max = area;
855 }
856 }
857 pixman_region32_fini(&region);
858
859 es->output = new_output;
860 weston_surface_update_output_mask(es, mask);
861}
862
863static void
864weston_view_assign_output(struct weston_view *ev)
865{
866 struct weston_compositor *ec = ev->surface->compositor;
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400867 struct weston_output *output, *new_output;
868 pixman_region32_t region;
869 uint32_t max, area, mask;
870 pixman_box32_t *e;
871
872 new_output = NULL;
873 max = 0;
874 mask = 0;
875 pixman_region32_init(&region);
876 wl_list_for_each(output, &ec->output_list, link) {
Jason Ekstranda7af7042013-10-12 22:38:11 -0500877 pixman_region32_intersect(&region, &ev->transform.boundingbox,
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400878 &output->region);
879
880 e = pixman_region32_extents(&region);
881 area = (e->x2 - e->x1) * (e->y2 - e->y1);
882
883 if (area > 0)
884 mask |= 1 << output->id;
885
886 if (area >= max) {
887 new_output = output;
888 max = area;
889 }
890 }
891 pixman_region32_fini(&region);
892
Jason Ekstranda7af7042013-10-12 22:38:11 -0500893 ev->output = new_output;
894 ev->output_mask = mask;
895
896 weston_surface_assign_output(ev->surface);
Kristian Høgsbergb9af4792012-09-25 14:48:04 -0400897}
898
Pekka Paalanen9abf3932012-02-08 14:49:37 +0200899static void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500900view_compute_bbox(struct weston_view *view, int32_t sx, int32_t sy,
901 int32_t width, int32_t height,
902 pixman_region32_t *bbox)
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200903{
John Kåre Alsaker490d02a2012-09-30 02:57:21 +0200904 float min_x = HUGE_VALF, min_y = HUGE_VALF;
905 float max_x = -HUGE_VALF, max_y = -HUGE_VALF;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200906 int32_t s[4][2] = {
907 { sx, sy },
908 { sx, sy + height },
909 { sx + width, sy },
910 { sx + width, sy + height }
911 };
John Kåre Alsaker490d02a2012-09-30 02:57:21 +0200912 float int_x, int_y;
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200913 int i;
914
Pekka Paalanen7c7d4642012-09-04 13:55:44 +0300915 if (width == 0 || height == 0) {
916 /* avoid rounding empty bbox to 1x1 */
917 pixman_region32_init(bbox);
918 return;
919 }
920
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200921 for (i = 0; i < 4; ++i) {
John Kåre Alsaker490d02a2012-09-30 02:57:21 +0200922 float x, y;
Jason Ekstranda7af7042013-10-12 22:38:11 -0500923 weston_view_to_global_float(view, s[i][0], s[i][1], &x, &y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200924 if (x < min_x)
925 min_x = x;
926 if (x > max_x)
927 max_x = x;
928 if (y < min_y)
929 min_y = y;
930 if (y > max_y)
931 max_y = y;
932 }
933
Pekka Paalanen219b9822012-02-08 15:38:37 +0200934 int_x = floorf(min_x);
935 int_y = floorf(min_y);
936 pixman_region32_init_rect(bbox, int_x, int_y,
937 ceilf(max_x) - int_x, ceilf(max_y) - int_y);
Pekka Paalanen6720d8f2012-01-25 15:17:40 +0200938}
939
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200940static void
Jason Ekstranda7af7042013-10-12 22:38:11 -0500941weston_view_update_transform_disable(struct weston_view *view)
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200942{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500943 view->transform.enabled = 0;
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200944
Pekka Paalanencc2f8682012-02-13 10:34:04 +0200945 /* round off fractions when not transformed */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500946 view->geometry.x = roundf(view->geometry.x);
947 view->geometry.y = roundf(view->geometry.y);
Pekka Paalanencc2f8682012-02-13 10:34:04 +0200948
Kristian Høgsbergc1e6c8a2013-02-19 17:04:50 -0500949 /* Otherwise identity matrix, but with x and y translation. */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500950 view->transform.position.matrix.type = WESTON_MATRIX_TRANSFORM_TRANSLATE;
951 view->transform.position.matrix.d[12] = view->geometry.x;
952 view->transform.position.matrix.d[13] = view->geometry.y;
Kristian Høgsbergc1e6c8a2013-02-19 17:04:50 -0500953
Jason Ekstranda7af7042013-10-12 22:38:11 -0500954 view->transform.matrix = view->transform.position.matrix;
Kristian Høgsbergc1e6c8a2013-02-19 17:04:50 -0500955
Jason Ekstranda7af7042013-10-12 22:38:11 -0500956 view->transform.inverse = view->transform.position.matrix;
957 view->transform.inverse.d[12] = -view->geometry.x;
958 view->transform.inverse.d[13] = -view->geometry.y;
Kristian Høgsbergc1e6c8a2013-02-19 17:04:50 -0500959
Jason Ekstranda7af7042013-10-12 22:38:11 -0500960 pixman_region32_init_rect(&view->transform.boundingbox,
961 view->geometry.x,
962 view->geometry.y,
Jason Ekstrand918f2dd2013-12-02 21:01:53 -0600963 view->surface->width,
964 view->surface->height);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -0500965
Jason Ekstranda7af7042013-10-12 22:38:11 -0500966 if (view->alpha == 1.0) {
967 pixman_region32_copy(&view->transform.opaque,
968 &view->surface->opaque);
969 pixman_region32_translate(&view->transform.opaque,
970 view->geometry.x,
971 view->geometry.y);
Kristian Høgsberg3b4af202012-02-28 09:19:39 -0500972 }
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200973}
974
975static int
Jason Ekstranda7af7042013-10-12 22:38:11 -0500976weston_view_update_transform_enable(struct weston_view *view)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200977{
Jason Ekstranda7af7042013-10-12 22:38:11 -0500978 struct weston_view *parent = view->geometry.parent;
979 struct weston_matrix *matrix = &view->transform.matrix;
980 struct weston_matrix *inverse = &view->transform.inverse;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +0200981 struct weston_transform *tform;
982
Jason Ekstranda7af7042013-10-12 22:38:11 -0500983 view->transform.enabled = 1;
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200984
985 /* Otherwise identity matrix, but with x and y translation. */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500986 view->transform.position.matrix.type = WESTON_MATRIX_TRANSFORM_TRANSLATE;
987 view->transform.position.matrix.d[12] = view->geometry.x;
988 view->transform.position.matrix.d[13] = view->geometry.y;
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200989
990 weston_matrix_init(matrix);
Jason Ekstranda7af7042013-10-12 22:38:11 -0500991 wl_list_for_each(tform, &view->geometry.transformation_list, link)
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200992 weston_matrix_multiply(matrix, &tform->matrix);
993
Pekka Paalanen483243f2013-03-08 14:56:50 +0200994 if (parent)
995 weston_matrix_multiply(matrix, &parent->transform.matrix);
996
Pekka Paalanen80fb08d2012-02-08 15:14:17 +0200997 if (weston_matrix_invert(inverse, matrix) < 0) {
998 /* Oops, bad total transformation, not invertible */
Jason Ekstranda7af7042013-10-12 22:38:11 -0500999 weston_log("error: weston_view %p"
1000 " transformation not invertible.\n", view);
Pekka Paalanen80fb08d2012-02-08 15:14:17 +02001001 return -1;
1002 }
1003
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001004 view_compute_bbox(view, 0, 0,
1005 view->surface->width, view->surface->height,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001006 &view->transform.boundingbox);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001007
Pekka Paalanen80fb08d2012-02-08 15:14:17 +02001008 return 0;
1009}
1010
1011WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001012weston_view_update_transform(struct weston_view *view)
Pekka Paalanen80fb08d2012-02-08 15:14:17 +02001013{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001014 struct weston_view *parent = view->geometry.parent;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001015
Jason Ekstranda7af7042013-10-12 22:38:11 -05001016 if (!view->transform.dirty)
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +02001017 return;
1018
Pekka Paalanen483243f2013-03-08 14:56:50 +02001019 if (parent)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001020 weston_view_update_transform(parent);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001021
Jason Ekstranda7af7042013-10-12 22:38:11 -05001022 view->transform.dirty = 0;
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +02001023
Jason Ekstranda7af7042013-10-12 22:38:11 -05001024 weston_view_damage_below(view);
Pekka Paalanen96516782012-02-09 15:32:15 +02001025
Jason Ekstranda7af7042013-10-12 22:38:11 -05001026 pixman_region32_fini(&view->transform.boundingbox);
1027 pixman_region32_fini(&view->transform.opaque);
1028 pixman_region32_init(&view->transform.opaque);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001029
Pekka Paalanencd403622012-01-25 13:37:39 +02001030 /* transform.position is always in transformation_list */
Jason Ekstranda7af7042013-10-12 22:38:11 -05001031 if (view->geometry.transformation_list.next ==
1032 &view->transform.position.link &&
1033 view->geometry.transformation_list.prev ==
1034 &view->transform.position.link &&
Pekka Paalanen483243f2013-03-08 14:56:50 +02001035 !parent) {
Jason Ekstranda7af7042013-10-12 22:38:11 -05001036 weston_view_update_transform_disable(view);
Pekka Paalanen80fb08d2012-02-08 15:14:17 +02001037 } else {
Jason Ekstranda7af7042013-10-12 22:38:11 -05001038 if (weston_view_update_transform_enable(view) < 0)
1039 weston_view_update_transform_disable(view);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +02001040 }
Pekka Paalanen96516782012-02-09 15:32:15 +02001041
Jason Ekstranda7af7042013-10-12 22:38:11 -05001042 weston_view_damage_below(view);
Pekka Paalanen96516782012-02-09 15:32:15 +02001043
Jason Ekstranda7af7042013-10-12 22:38:11 -05001044 weston_view_assign_output(view);
Tiago Vignattifb2adba2013-06-12 15:43:21 -03001045
Jason Ekstranda7af7042013-10-12 22:38:11 -05001046 wl_signal_emit(&view->surface->compositor->transform_signal,
1047 view->surface);
Pekka Paalanen2a5cecc2012-01-20 14:24:25 +02001048}
1049
Pekka Paalanenddae03c2012-02-06 14:54:20 +02001050WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001051weston_view_geometry_dirty(struct weston_view *view)
Pekka Paalanenc3ce7382013-03-08 14:56:49 +02001052{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001053 struct weston_view *child;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001054
1055 /*
Jason Ekstranda7af7042013-10-12 22:38:11 -05001056 * The invariant: if view->geometry.dirty, then all views
1057 * in view->geometry.child_list have geometry.dirty too.
Pekka Paalanen483243f2013-03-08 14:56:50 +02001058 * Corollary: if not parent->geometry.dirty, then all ancestors
1059 * are not dirty.
1060 */
1061
Jason Ekstranda7af7042013-10-12 22:38:11 -05001062 if (view->transform.dirty)
Pekka Paalanen483243f2013-03-08 14:56:50 +02001063 return;
1064
Jason Ekstranda7af7042013-10-12 22:38:11 -05001065 view->transform.dirty = 1;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001066
Jason Ekstranda7af7042013-10-12 22:38:11 -05001067 wl_list_for_each(child, &view->geometry.child_list,
Pekka Paalanen483243f2013-03-08 14:56:50 +02001068 geometry.parent_link)
Jason Ekstranda7af7042013-10-12 22:38:11 -05001069 weston_view_geometry_dirty(child);
Pekka Paalanenc3ce7382013-03-08 14:56:49 +02001070}
1071
1072WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001073weston_view_to_global_fixed(struct weston_view *view,
1074 wl_fixed_t vx, wl_fixed_t vy,
1075 wl_fixed_t *x, wl_fixed_t *y)
Daniel Stonebd3489b2012-05-08 17:17:53 +01001076{
John Kåre Alsaker490d02a2012-09-30 02:57:21 +02001077 float xf, yf;
Daniel Stonebd3489b2012-05-08 17:17:53 +01001078
Jason Ekstranda7af7042013-10-12 22:38:11 -05001079 weston_view_to_global_float(view,
1080 wl_fixed_to_double(vx),
1081 wl_fixed_to_double(vy),
1082 &xf, &yf);
Daniel Stonebd3489b2012-05-08 17:17:53 +01001083 *x = wl_fixed_from_double(xf);
1084 *y = wl_fixed_from_double(yf);
1085}
1086
Kristian Høgsbergecf6ede2012-09-05 21:59:35 -04001087WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001088weston_view_from_global_float(struct weston_view *view,
1089 float x, float y, float *vx, float *vy)
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001090{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001091 if (view->transform.enabled) {
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001092 struct weston_vector v = { { x, y, 0.0f, 1.0f } };
1093
Jason Ekstranda7af7042013-10-12 22:38:11 -05001094 weston_matrix_transform(&view->transform.inverse, &v);
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001095
1096 if (fabsf(v.f[3]) < 1e-6) {
Martin Minarik6d118362012-06-07 18:01:59 +02001097 weston_log("warning: numerical instability in "
Jason Ekstranda7af7042013-10-12 22:38:11 -05001098 "weston_view_from_global(), divisor = %g\n",
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001099 v.f[3]);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001100 *vx = 0;
1101 *vy = 0;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001102 return;
1103 }
1104
Jason Ekstranda7af7042013-10-12 22:38:11 -05001105 *vx = v.f[0] / v.f[3];
1106 *vy = v.f[1] / v.f[3];
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001107 } else {
Jason Ekstranda7af7042013-10-12 22:38:11 -05001108 *vx = x - view->geometry.x;
1109 *vy = y - view->geometry.y;
Pekka Paalanene0f3cb22012-01-24 09:59:29 +02001110 }
1111}
1112
1113WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001114weston_view_from_global_fixed(struct weston_view *view,
1115 wl_fixed_t x, wl_fixed_t y,
1116 wl_fixed_t *vx, wl_fixed_t *vy)
Daniel Stonebd3489b2012-05-08 17:17:53 +01001117{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001118 float vxf, vyf;
Daniel Stonebd3489b2012-05-08 17:17:53 +01001119
Jason Ekstranda7af7042013-10-12 22:38:11 -05001120 weston_view_from_global_float(view,
1121 wl_fixed_to_double(x),
1122 wl_fixed_to_double(y),
1123 &vxf, &vyf);
1124 *vx = wl_fixed_from_double(vxf);
1125 *vy = wl_fixed_from_double(vyf);
Daniel Stonebd3489b2012-05-08 17:17:53 +01001126}
1127
1128WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001129weston_view_from_global(struct weston_view *view,
1130 int32_t x, int32_t y, int32_t *vx, int32_t *vy)
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001131{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001132 float vxf, vyf;
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001133
Jason Ekstranda7af7042013-10-12 22:38:11 -05001134 weston_view_from_global_float(view, x, y, &vxf, &vyf);
1135 *vx = floorf(vxf);
1136 *vy = floorf(vyf);
Pekka Paalanen0e151bb2012-01-24 14:47:37 +02001137}
1138
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001139WL_EXPORT void
Kristian Høgsberg98238702012-08-03 16:29:12 -04001140weston_surface_schedule_repaint(struct weston_surface *surface)
1141{
1142 struct weston_output *output;
1143
1144 wl_list_for_each(output, &surface->compositor->output_list, link)
1145 if (surface->output_mask & (1 << output->id))
1146 weston_output_schedule_repaint(output);
1147}
1148
1149WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001150weston_view_schedule_repaint(struct weston_view *view)
1151{
1152 struct weston_output *output;
1153
1154 wl_list_for_each(output, &view->surface->compositor->output_list, link)
1155 if (view->output_mask & (1 << output->id))
1156 weston_output_schedule_repaint(output);
1157}
1158
1159WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001160weston_surface_damage(struct weston_surface *surface)
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001161{
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001162 pixman_region32_union_rect(&surface->damage, &surface->damage,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001163 0, 0, surface->width,
1164 surface->height);
Pekka Paalanen2267d452012-01-26 13:12:45 +02001165
Kristian Høgsberg98238702012-08-03 16:29:12 -04001166 weston_surface_schedule_repaint(surface);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001167}
1168
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001169WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001170weston_view_set_position(struct weston_view *view, float x, float y)
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +02001171{
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001172 if (view->geometry.x == x && view->geometry.y == y)
1173 return;
1174
Jason Ekstranda7af7042013-10-12 22:38:11 -05001175 view->geometry.x = x;
1176 view->geometry.y = y;
1177 weston_view_geometry_dirty(view);
Pekka Paalanen8fb8d3b2012-02-13 13:03:59 +02001178}
1179
Pekka Paalanen483243f2013-03-08 14:56:50 +02001180static void
1181transform_parent_handle_parent_destroy(struct wl_listener *listener,
1182 void *data)
1183{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001184 struct weston_view *view =
1185 container_of(listener, struct weston_view,
Pekka Paalanen483243f2013-03-08 14:56:50 +02001186 geometry.parent_destroy_listener);
1187
Jason Ekstranda7af7042013-10-12 22:38:11 -05001188 weston_view_set_transform_parent(view, NULL);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001189}
1190
1191WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001192weston_view_set_transform_parent(struct weston_view *view,
1193 struct weston_view *parent)
Pekka Paalanen483243f2013-03-08 14:56:50 +02001194{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001195 if (view->geometry.parent) {
1196 wl_list_remove(&view->geometry.parent_destroy_listener.link);
1197 wl_list_remove(&view->geometry.parent_link);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001198 }
1199
Jason Ekstranda7af7042013-10-12 22:38:11 -05001200 view->geometry.parent = parent;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001201
Jason Ekstranda7af7042013-10-12 22:38:11 -05001202 view->geometry.parent_destroy_listener.notify =
Pekka Paalanen483243f2013-03-08 14:56:50 +02001203 transform_parent_handle_parent_destroy;
1204 if (parent) {
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001205 wl_signal_add(&parent->destroy_signal,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001206 &view->geometry.parent_destroy_listener);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001207 wl_list_insert(&parent->geometry.child_list,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001208 &view->geometry.parent_link);
Pekka Paalanen483243f2013-03-08 14:56:50 +02001209 }
1210
Jason Ekstranda7af7042013-10-12 22:38:11 -05001211 weston_view_geometry_dirty(view);
1212}
1213
1214WL_EXPORT int
1215weston_view_is_mapped(struct weston_view *view)
1216{
1217 if (view->output)
1218 return 1;
1219 else
1220 return 0;
Pekka Paalanen483243f2013-03-08 14:56:50 +02001221}
1222
Ander Conselvan de Oliveirab8ab14f2012-03-27 17:36:36 +03001223WL_EXPORT int
1224weston_surface_is_mapped(struct weston_surface *surface)
1225{
1226 if (surface->output)
1227 return 1;
1228 else
1229 return 0;
1230}
1231
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001232static void
Jason Ekstrand5c11a332013-12-04 20:32:03 -06001233surface_set_size(struct weston_surface *surface, int32_t width, int32_t height)
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001234{
1235 struct weston_view *view;
1236
1237 if (surface->width == width && surface->height == height)
1238 return;
1239
1240 surface->width = width;
1241 surface->height = height;
1242
1243 wl_list_for_each(view, &surface->views, surface_link)
1244 weston_view_geometry_dirty(view);
1245}
1246
Jason Ekstrand5c11a332013-12-04 20:32:03 -06001247WL_EXPORT void
1248weston_surface_set_size(struct weston_surface *surface,
1249 int32_t width, int32_t height)
1250{
1251 assert(!surface->resource);
1252 surface_set_size(surface, width, height);
1253}
1254
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001255static int
1256fixed_round_up_to_int(wl_fixed_t f)
1257{
1258 return wl_fixed_to_int(wl_fixed_from_int(1) - 1 + f);
1259}
1260
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001261static void
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02001262weston_surface_calculate_size_from_buffer(struct weston_surface *surface)
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001263{
Pekka Paalanen952b6c82014-03-14 14:38:15 +02001264 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001265 int32_t width, height;
1266
1267 if (!surface->buffer_ref.buffer) {
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001268 surface->width_from_buffer = 0;
1269 surface->height_from_buffer = 0;
Jonny Lamb74130762013-11-26 18:19:46 +01001270 return;
1271 }
1272
Pekka Paalanen952b6c82014-03-14 14:38:15 +02001273 switch (vp->buffer.transform) {
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001274 case WL_OUTPUT_TRANSFORM_90:
1275 case WL_OUTPUT_TRANSFORM_270:
1276 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
1277 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001278 width = surface->buffer_ref.buffer->height / vp->buffer.scale;
1279 height = surface->buffer_ref.buffer->width / vp->buffer.scale;
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001280 break;
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001281 default:
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001282 width = surface->buffer_ref.buffer->width / vp->buffer.scale;
1283 height = surface->buffer_ref.buffer->height / vp->buffer.scale;
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001284 break;
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001285 }
Pekka Paalanenda75ee12013-11-26 18:19:43 +01001286
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001287 surface->width_from_buffer = width;
1288 surface->height_from_buffer = height;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02001289}
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001290
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02001291static void
1292weston_surface_update_size(struct weston_surface *surface)
1293{
1294 struct weston_buffer_viewport *vp = &surface->buffer_viewport;
1295 int32_t width, height;
1296
1297 width = surface->width_from_buffer;
1298 height = surface->height_from_buffer;
1299
1300 if (width != 0 && vp->surface.width != -1) {
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001301 surface_set_size(surface,
1302 vp->surface.width, vp->surface.height);
1303 return;
1304 }
1305
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02001306 if (width != 0 && vp->buffer.src_width != wl_fixed_from_int(-1)) {
Pekka Paalanene9317212014-04-04 14:22:13 +03001307 int32_t w = fixed_round_up_to_int(vp->buffer.src_width);
1308 int32_t h = fixed_round_up_to_int(vp->buffer.src_height);
1309
1310 surface_set_size(surface, w ?: 1, h ?: 1);
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02001311 return;
1312 }
1313
Jason Ekstrand5c11a332013-12-04 20:32:03 -06001314 surface_set_size(surface, width, height);
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02001315}
1316
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001317WL_EXPORT uint32_t
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001318weston_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -05001319{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001320 struct timeval tv;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -05001321
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001322 gettimeofday(&tv, NULL);
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -05001323
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001324 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -05001325}
1326
Jason Ekstranda7af7042013-10-12 22:38:11 -05001327WL_EXPORT struct weston_view *
1328weston_compositor_pick_view(struct weston_compositor *compositor,
1329 wl_fixed_t x, wl_fixed_t y,
1330 wl_fixed_t *vx, wl_fixed_t *vy)
Tiago Vignatti9d393522012-02-10 16:26:19 +02001331{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001332 struct weston_view *view;
Tiago Vignatti9d393522012-02-10 16:26:19 +02001333
Jason Ekstranda7af7042013-10-12 22:38:11 -05001334 wl_list_for_each(view, &compositor->view_list, link) {
1335 weston_view_from_global_fixed(view, x, y, vx, vy);
1336 if (pixman_region32_contains_point(&view->surface->input,
1337 wl_fixed_to_int(*vx),
1338 wl_fixed_to_int(*vy),
Daniel Stone103db7f2012-05-08 17:17:55 +01001339 NULL))
Jason Ekstranda7af7042013-10-12 22:38:11 -05001340 return view;
Tiago Vignatti9d393522012-02-10 16:26:19 +02001341 }
1342
1343 return NULL;
1344}
1345
1346static void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001347weston_compositor_repick(struct weston_compositor *compositor)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001348{
Daniel Stone37816df2012-05-16 18:45:18 +01001349 struct weston_seat *seat;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001350
Kristian Høgsberg10ddd972013-10-22 12:40:54 -07001351 if (!compositor->session_active)
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -05001352 return;
1353
Daniel Stone37816df2012-05-16 18:45:18 +01001354 wl_list_for_each(seat, &compositor->seat_list, link)
Kristian Høgsberga71e8b22013-05-06 21:51:21 -04001355 weston_seat_repick(seat);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001356}
1357
Kristian Høgsbergaf7b1ff2012-06-26 21:19:23 -04001358WL_EXPORT void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001359weston_view_unmap(struct weston_view *view)
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -05001360{
Daniel Stone4dab5db2012-05-30 16:31:53 +01001361 struct weston_seat *seat;
Kristian Høgsberg867dec72012-03-01 17:09:37 -05001362
Jason Ekstranda7af7042013-10-12 22:38:11 -05001363 if (!weston_view_is_mapped(view))
1364 return;
Kristian Høgsberg867dec72012-03-01 17:09:37 -05001365
Jason Ekstranda7af7042013-10-12 22:38:11 -05001366 weston_view_damage_below(view);
1367 view->output = NULL;
Xiong Zhang97116532013-10-23 13:58:31 +08001368 view->plane = NULL;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001369 wl_list_remove(&view->layer_link);
1370 wl_list_init(&view->layer_link);
1371 wl_list_remove(&view->link);
1372 wl_list_init(&view->link);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001373 view->output_mask = 0;
1374 weston_surface_assign_output(view->surface);
1375
1376 if (weston_surface_is_mapped(view->surface))
1377 return;
1378
1379 wl_list_for_each(seat, &view->surface->compositor->seat_list, link) {
1380 if (seat->keyboard && seat->keyboard->focus == view->surface)
Kristian Høgsberge3148752013-05-06 23:19:49 -04001381 weston_keyboard_set_focus(seat->keyboard, NULL);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001382 if (seat->pointer && seat->pointer->focus == view)
Kristian Høgsberge3148752013-05-06 23:19:49 -04001383 weston_pointer_set_focus(seat->pointer,
Kristian Høgsberg02bbabb2013-05-06 22:15:05 -04001384 NULL,
1385 wl_fixed_from_int(0),
1386 wl_fixed_from_int(0));
Jason Ekstranda7af7042013-10-12 22:38:11 -05001387 if (seat->touch && seat->touch->focus == view)
Michael Fua2bb7912013-07-23 15:51:06 +08001388 weston_touch_set_focus(seat, NULL);
Daniel Stone4dab5db2012-05-30 16:31:53 +01001389 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001390}
Kristian Høgsberg867dec72012-03-01 17:09:37 -05001391
Jason Ekstranda7af7042013-10-12 22:38:11 -05001392WL_EXPORT void
1393weston_surface_unmap(struct weston_surface *surface)
1394{
1395 struct weston_view *view;
1396
1397 wl_list_for_each(view, &surface->views, surface_link)
1398 weston_view_unmap(view);
1399 surface->output = NULL;
Kristian Høgsberg3b5ea3b2012-02-17 12:43:56 -05001400}
1401
Pekka Paalanen3c9b8022014-03-14 14:38:13 +02001402static void
1403weston_surface_reset_pending_buffer(struct weston_surface *surface)
1404{
Jason Ekstrand7b982072014-05-20 14:33:03 -05001405 weston_surface_state_set_buffer(&surface->pending, NULL);
Pekka Paalanen3c9b8022014-03-14 14:38:13 +02001406 surface->pending.sx = 0;
1407 surface->pending.sy = 0;
1408 surface->pending.newly_attached = 0;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02001409 surface->pending.buffer_viewport.changed = 0;
Pekka Paalanen3c9b8022014-03-14 14:38:13 +02001410}
1411
Jason Ekstranda7af7042013-10-12 22:38:11 -05001412WL_EXPORT void
1413weston_view_destroy(struct weston_view *view)
1414{
1415 wl_signal_emit(&view->destroy_signal, view);
1416
1417 assert(wl_list_empty(&view->geometry.child_list));
1418
1419 if (weston_view_is_mapped(view)) {
1420 weston_view_unmap(view);
1421 weston_compositor_build_view_list(view->surface->compositor);
1422 }
1423
1424 wl_list_remove(&view->link);
1425 wl_list_remove(&view->layer_link);
1426
1427 pixman_region32_fini(&view->clip);
1428 pixman_region32_fini(&view->transform.boundingbox);
1429
1430 weston_view_set_transform_parent(view, NULL);
1431
Jason Ekstranda7af7042013-10-12 22:38:11 -05001432 wl_list_remove(&view->surface_link);
1433
1434 free(view);
1435}
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001436
1437WL_EXPORT void
1438weston_surface_destroy(struct weston_surface *surface)
Kristian Høgsberg54879822008-11-23 17:07:32 -05001439{
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -04001440 struct weston_frame_callback *cb, *next;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001441 struct weston_view *ev, *nv;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -04001442
Giulio Camuffo13b85bd2013-08-13 23:10:14 +02001443 if (--surface->ref_count > 0)
1444 return;
1445
1446 wl_signal_emit(&surface->destroy_signal, &surface->resource);
1447
Pekka Paalanene67858b2013-04-25 13:57:42 +03001448 assert(wl_list_empty(&surface->subsurface_list_pending));
1449 assert(wl_list_empty(&surface->subsurface_list));
Pekka Paalanen483243f2013-03-08 14:56:50 +02001450
Jason Ekstranda7af7042013-10-12 22:38:11 -05001451 wl_list_for_each_safe(ev, nv, &surface->views, surface_link)
1452 weston_view_destroy(ev);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001453
Jason Ekstrand7b982072014-05-20 14:33:03 -05001454 weston_surface_state_fini(&surface->pending);
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001455
Pekka Paalanende685b82012-12-04 15:58:12 +02001456 weston_buffer_reference(&surface->buffer_ref, NULL);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -04001457
Pekka Paalanen402ae6d2012-01-03 10:23:24 +02001458 pixman_region32_fini(&surface->damage);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05001459 pixman_region32_fini(&surface->opaque);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03001460 pixman_region32_fini(&surface->input);
Pekka Paalanen402ae6d2012-01-03 10:23:24 +02001461
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -04001462 wl_list_for_each_safe(cb, next, &surface->frame_callback_list, link)
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05001463 wl_resource_destroy(cb->resource);
Kristian Høgsberg1e51fec2012-07-22 11:33:14 -04001464
Kristian Høgsberg4fa48732009-03-10 23:17:00 -04001465 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -05001466}
1467
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001468static void
1469destroy_surface(struct wl_resource *resource)
Alex Wu8811bf92012-02-28 18:07:54 +08001470{
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001471 struct weston_surface *surface = wl_resource_get_user_data(resource);
Alex Wu8811bf92012-02-28 18:07:54 +08001472
Giulio Camuffo0d379742013-11-15 22:06:15 +01001473 /* Set the resource to NULL, since we don't want to leave a
1474 * dangling pointer if the surface was refcounted and survives
1475 * the weston_surface_destroy() call. */
1476 surface->resource = NULL;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05001477 weston_surface_destroy(surface);
Alex Wu8811bf92012-02-28 18:07:54 +08001478}
1479
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +01001480static void
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001481weston_buffer_destroy_handler(struct wl_listener *listener, void *data)
1482{
1483 struct weston_buffer *buffer =
1484 container_of(listener, struct weston_buffer, destroy_listener);
1485
1486 wl_signal_emit(&buffer->destroy_signal, buffer);
1487 free(buffer);
1488}
1489
Giulio Camuffoe058cd12013-12-12 14:14:29 +01001490WL_EXPORT struct weston_buffer *
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001491weston_buffer_from_resource(struct wl_resource *resource)
1492{
1493 struct weston_buffer *buffer;
1494 struct wl_listener *listener;
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08001495
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001496 listener = wl_resource_get_destroy_listener(resource,
1497 weston_buffer_destroy_handler);
1498
Kristian Høgsberg08b58c72013-08-15 12:26:42 -07001499 if (listener)
1500 return container_of(listener, struct weston_buffer,
1501 destroy_listener);
1502
1503 buffer = zalloc(sizeof *buffer);
1504 if (buffer == NULL)
1505 return NULL;
1506
1507 buffer->resource = resource;
1508 wl_signal_init(&buffer->destroy_signal);
1509 buffer->destroy_listener.notify = weston_buffer_destroy_handler;
Stanislav Vorobiovbfbb8e52013-08-29 11:36:44 +04001510 buffer->y_inverted = 1;
Kristian Høgsberg08b58c72013-08-15 12:26:42 -07001511 wl_resource_add_destroy_listener(resource, &buffer->destroy_listener);
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08001512
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001513 return buffer;
1514}
1515
1516static void
Pekka Paalanende685b82012-12-04 15:58:12 +02001517weston_buffer_reference_handle_destroy(struct wl_listener *listener,
1518 void *data)
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +01001519{
Pekka Paalanende685b82012-12-04 15:58:12 +02001520 struct weston_buffer_reference *ref =
1521 container_of(listener, struct weston_buffer_reference,
1522 destroy_listener);
1523
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001524 assert((struct weston_buffer *)data == ref->buffer);
Pekka Paalanende685b82012-12-04 15:58:12 +02001525 ref->buffer = NULL;
1526}
1527
1528WL_EXPORT void
1529weston_buffer_reference(struct weston_buffer_reference *ref,
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001530 struct weston_buffer *buffer)
Pekka Paalanende685b82012-12-04 15:58:12 +02001531{
1532 if (ref->buffer && buffer != ref->buffer) {
Kristian Høgsberg20347802013-03-04 12:07:46 -05001533 ref->buffer->busy_count--;
1534 if (ref->buffer->busy_count == 0) {
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001535 assert(wl_resource_get_client(ref->buffer->resource));
1536 wl_resource_queue_event(ref->buffer->resource,
Kristian Høgsberg20347802013-03-04 12:07:46 -05001537 WL_BUFFER_RELEASE);
1538 }
Pekka Paalanende685b82012-12-04 15:58:12 +02001539 wl_list_remove(&ref->destroy_listener.link);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001540 }
1541
Pekka Paalanende685b82012-12-04 15:58:12 +02001542 if (buffer && buffer != ref->buffer) {
Kristian Høgsbergb7b77e62012-09-05 22:38:18 -04001543 buffer->busy_count++;
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001544 wl_signal_add(&buffer->destroy_signal,
Pekka Paalanende685b82012-12-04 15:58:12 +02001545 &ref->destroy_listener);
Pekka Paalanena6421c42012-12-04 15:58:10 +02001546 }
1547
Pekka Paalanende685b82012-12-04 15:58:12 +02001548 ref->buffer = buffer;
1549 ref->destroy_listener.notify = weston_buffer_reference_handle_destroy;
1550}
1551
1552static void
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001553weston_surface_attach(struct weston_surface *surface,
1554 struct weston_buffer *buffer)
Pekka Paalanende685b82012-12-04 15:58:12 +02001555{
1556 weston_buffer_reference(&surface->buffer_ref, buffer);
1557
Pekka Paalanena6421c42012-12-04 15:58:10 +02001558 if (!buffer) {
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001559 if (weston_surface_is_mapped(surface))
1560 weston_surface_unmap(surface);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001561 }
1562
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001563 surface->compositor->renderer->attach(surface, buffer);
Pekka Paalanenbb2f3f22014-03-14 14:38:11 +02001564
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02001565 weston_surface_calculate_size_from_buffer(surface);
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +01001566}
1567
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001568WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001569weston_compositor_damage_all(struct weston_compositor *compositor)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001570{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001571 struct weston_output *output;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001572
1573 wl_list_for_each(output, &compositor->output_list, link)
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001574 weston_output_damage(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001575}
1576
Kristian Høgsberg9f404b72012-01-26 00:11:01 -05001577WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001578weston_output_damage(struct weston_output *output)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001579{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001580 struct weston_compositor *compositor = output->compositor;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001581
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04001582 pixman_region32_union(&compositor->primary_plane.damage,
1583 &compositor->primary_plane.damage,
1584 &output->region);
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001585 weston_output_schedule_repaint(output);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001586}
1587
Kristian Høgsberg01f941b2009-05-27 17:47:15 -04001588static void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001589surface_flush_damage(struct weston_surface *surface)
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001590{
Pekka Paalanende685b82012-12-04 15:58:12 +02001591 if (surface->buffer_ref.buffer &&
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001592 wl_shm_buffer_get(surface->buffer_ref.buffer->resource))
Kristian Høgsbergfa1be022012-09-05 22:49:55 -04001593 surface->compositor->renderer->flush_damage(surface);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001594
Jason Ekstrandef540082014-06-26 10:37:36 -07001595 pixman_region32_clear(&surface->damage);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001596}
1597
1598static void
1599view_accumulate_damage(struct weston_view *view,
1600 pixman_region32_t *opaque)
1601{
1602 pixman_region32_t damage;
1603
1604 pixman_region32_init(&damage);
1605 if (view->transform.enabled) {
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001606 pixman_box32_t *extents;
1607
Jason Ekstranda7af7042013-10-12 22:38:11 -05001608 extents = pixman_region32_extents(&view->surface->damage);
1609 view_compute_bbox(view, extents->x1, extents->y1,
1610 extents->x2 - extents->x1,
1611 extents->y2 - extents->y1,
1612 &damage);
1613 pixman_region32_translate(&damage,
1614 -view->plane->x,
1615 -view->plane->y);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001616 } else {
Jason Ekstranda7af7042013-10-12 22:38:11 -05001617 pixman_region32_copy(&damage, &view->surface->damage);
1618 pixman_region32_translate(&damage,
1619 view->geometry.x - view->plane->x,
1620 view->geometry.y - view->plane->y);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001621 }
1622
Jason Ekstranda7af7042013-10-12 22:38:11 -05001623 pixman_region32_subtract(&damage, &damage, opaque);
1624 pixman_region32_union(&view->plane->damage,
1625 &view->plane->damage, &damage);
1626 pixman_region32_fini(&damage);
1627 pixman_region32_copy(&view->clip, opaque);
1628 pixman_region32_union(opaque, opaque, &view->transform.opaque);
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001629}
1630
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001631static void
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001632compositor_accumulate_damage(struct weston_compositor *ec)
1633{
1634 struct weston_plane *plane;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001635 struct weston_view *ev;
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001636 pixman_region32_t opaque, clip;
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001637
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001638 pixman_region32_init(&clip);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001639
1640 wl_list_for_each(plane, &ec->plane_list, link) {
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001641 pixman_region32_copy(&plane->clip, &clip);
1642
1643 pixman_region32_init(&opaque);
1644
Jason Ekstranda7af7042013-10-12 22:38:11 -05001645 wl_list_for_each(ev, &ec->view_list, link) {
1646 if (ev->plane != plane)
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001647 continue;
1648
Jason Ekstranda7af7042013-10-12 22:38:11 -05001649 view_accumulate_damage(ev, &opaque);
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001650 }
1651
1652 pixman_region32_union(&clip, &clip, &opaque);
1653 pixman_region32_fini(&opaque);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001654 }
1655
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001656 pixman_region32_fini(&clip);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001657
Jason Ekstranda7af7042013-10-12 22:38:11 -05001658 wl_list_for_each(ev, &ec->view_list, link)
1659 ev->surface->touched = 0;
1660
1661 wl_list_for_each(ev, &ec->view_list, link) {
1662 if (ev->surface->touched)
1663 continue;
1664 ev->surface->touched = 1;
1665
1666 surface_flush_damage(ev->surface);
1667
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001668 /* Both the renderer and the backend have seen the buffer
1669 * by now. If renderer needs the buffer, it has its own
1670 * reference set. If the backend wants to keep the buffer
1671 * around for migrating the surface into a non-primary plane
1672 * later, keep_buffer is true. Otherwise, drop the core
1673 * reference now, and allow early buffer release. This enables
1674 * clients to use single-buffering.
1675 */
Jason Ekstranda7af7042013-10-12 22:38:11 -05001676 if (!ev->surface->keep_buffer)
1677 weston_buffer_reference(&ev->surface->buffer_ref, NULL);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001678 }
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001679}
1680
1681static void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001682surface_stash_subsurface_views(struct weston_surface *surface)
Pekka Paalanene67858b2013-04-25 13:57:42 +03001683{
1684 struct weston_subsurface *sub;
1685
Pekka Paalanene67858b2013-04-25 13:57:42 +03001686 wl_list_for_each(sub, &surface->subsurface_list, parent_link) {
Jason Ekstranda7af7042013-10-12 22:38:11 -05001687 if (sub->surface == surface)
Pekka Paalanene67858b2013-04-25 13:57:42 +03001688 continue;
1689
Jason Ekstranda7af7042013-10-12 22:38:11 -05001690 wl_list_insert_list(&sub->unused_views, &sub->surface->views);
1691 wl_list_init(&sub->surface->views);
1692
1693 surface_stash_subsurface_views(sub->surface);
Pekka Paalanene67858b2013-04-25 13:57:42 +03001694 }
1695}
1696
1697static void
Jason Ekstranda7af7042013-10-12 22:38:11 -05001698surface_free_unused_subsurface_views(struct weston_surface *surface)
Pekka Paalanene67858b2013-04-25 13:57:42 +03001699{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001700 struct weston_subsurface *sub;
1701 struct weston_view *view, *nv;
Pekka Paalanene67858b2013-04-25 13:57:42 +03001702
Jason Ekstranda7af7042013-10-12 22:38:11 -05001703 wl_list_for_each(sub, &surface->subsurface_list, parent_link) {
1704 if (sub->surface == surface)
1705 continue;
1706
George Kiagiadakised04d382014-06-13 18:10:26 +02001707 wl_list_for_each_safe(view, nv, &sub->unused_views, surface_link) {
1708 weston_view_unmap (view);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001709 weston_view_destroy(view);
George Kiagiadakised04d382014-06-13 18:10:26 +02001710 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001711
1712 surface_free_unused_subsurface_views(sub->surface);
1713 }
1714}
1715
1716static void
1717view_list_add_subsurface_view(struct weston_compositor *compositor,
1718 struct weston_subsurface *sub,
1719 struct weston_view *parent)
1720{
1721 struct weston_subsurface *child;
1722 struct weston_view *view = NULL, *iv;
1723
1724 wl_list_for_each(iv, &sub->unused_views, surface_link) {
1725 if (iv->geometry.parent == parent) {
1726 view = iv;
1727 break;
Pekka Paalanene67858b2013-04-25 13:57:42 +03001728 }
1729 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001730
1731 if (view) {
1732 /* Put it back in the surface's list of views */
1733 wl_list_remove(&view->surface_link);
1734 wl_list_insert(&sub->surface->views, &view->surface_link);
1735 } else {
1736 view = weston_view_create(sub->surface);
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06001737 weston_view_set_position(view,
1738 sub->position.x,
1739 sub->position.y);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001740 weston_view_set_transform_parent(view, parent);
1741 }
1742
1743 weston_view_update_transform(view);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001744
Pekka Paalanenb188e912013-11-19 14:03:35 +02001745 if (wl_list_empty(&sub->surface->subsurface_list)) {
1746 wl_list_insert(compositor->view_list.prev, &view->link);
1747 return;
1748 }
1749
1750 wl_list_for_each(child, &sub->surface->subsurface_list, parent_link) {
1751 if (child->surface == sub->surface)
1752 wl_list_insert(compositor->view_list.prev, &view->link);
1753 else
Jason Ekstranda7af7042013-10-12 22:38:11 -05001754 view_list_add_subsurface_view(compositor, child, view);
Pekka Paalanenb188e912013-11-19 14:03:35 +02001755 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001756}
1757
1758static void
1759view_list_add(struct weston_compositor *compositor,
1760 struct weston_view *view)
1761{
1762 struct weston_subsurface *sub;
1763
1764 weston_view_update_transform(view);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001765
Pekka Paalanenb188e912013-11-19 14:03:35 +02001766 if (wl_list_empty(&view->surface->subsurface_list)) {
1767 wl_list_insert(compositor->view_list.prev, &view->link);
1768 return;
1769 }
1770
1771 wl_list_for_each(sub, &view->surface->subsurface_list, parent_link) {
1772 if (sub->surface == view->surface)
1773 wl_list_insert(compositor->view_list.prev, &view->link);
1774 else
Jason Ekstranda7af7042013-10-12 22:38:11 -05001775 view_list_add_subsurface_view(compositor, sub, view);
Pekka Paalanenb188e912013-11-19 14:03:35 +02001776 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05001777}
1778
1779static void
1780weston_compositor_build_view_list(struct weston_compositor *compositor)
1781{
1782 struct weston_view *view;
1783 struct weston_layer *layer;
1784
1785 wl_list_for_each(layer, &compositor->layer_list, link)
1786 wl_list_for_each(view, &layer->view_list, layer_link)
1787 surface_stash_subsurface_views(view->surface);
1788
1789 wl_list_init(&compositor->view_list);
1790 wl_list_for_each(layer, &compositor->layer_list, link) {
1791 wl_list_for_each(view, &layer->view_list, layer_link) {
1792 view_list_add(compositor, view);
1793 }
1794 }
1795
1796 wl_list_for_each(layer, &compositor->layer_list, link)
1797 wl_list_for_each(view, &layer->view_list, layer_link)
1798 surface_free_unused_subsurface_views(view->surface);
Pekka Paalanene67858b2013-04-25 13:57:42 +03001799}
1800
David Herrmann1edf44c2013-10-22 17:11:26 +02001801static int
Rob Bradford0fb79752012-08-02 15:36:57 +01001802weston_output_repaint(struct weston_output *output, uint32_t msecs)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001803{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05001804 struct weston_compositor *ec = output->compositor;
Jason Ekstranda7af7042013-10-12 22:38:11 -05001805 struct weston_view *ev;
Kristian Høgsberg30c018b2012-01-26 08:40:37 -05001806 struct weston_animation *animation, *next;
1807 struct weston_frame_callback *cb, *cnext;
Jonas Ådahldb773762012-06-13 00:01:21 +02001808 struct wl_list frame_callback_list;
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001809 pixman_region32_t output_damage;
David Herrmann1edf44c2013-10-22 17:11:26 +02001810 int r;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001811
Ander Conselvan de Oliveirae1e23522013-12-13 22:10:55 +02001812 if (output->destroying)
1813 return 0;
1814
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001815 /* Rebuild the surface list and update surface transforms up front. */
Jason Ekstranda7af7042013-10-12 22:38:11 -05001816 weston_compositor_build_view_list(ec);
Pekka Paalanen15d60ef2012-01-27 14:38:33 +02001817
Kristian Høgsberg79af73e2012-08-03 15:45:23 -04001818 if (output->assign_planes && !output->disable_planes)
Jesse Barnes5308a5e2012-02-09 13:12:57 -08001819 output->assign_planes(output);
Kristian Høgsberg79af73e2012-08-03 15:45:23 -04001820 else
Jason Ekstranda7af7042013-10-12 22:38:11 -05001821 wl_list_for_each(ev, &ec->view_list, link)
1822 weston_view_move_to_plane(ev, &ec->primary_plane);
Kristian Høgsberg79af73e2012-08-03 15:45:23 -04001823
Pekka Paalanene67858b2013-04-25 13:57:42 +03001824 wl_list_init(&frame_callback_list);
Jason Ekstranda7af7042013-10-12 22:38:11 -05001825 wl_list_for_each(ev, &ec->view_list, link) {
1826 /* Note: This operation is safe to do multiple times on the
1827 * same surface.
1828 */
1829 if (ev->surface->output == output) {
Pekka Paalanene67858b2013-04-25 13:57:42 +03001830 wl_list_insert_list(&frame_callback_list,
Jason Ekstranda7af7042013-10-12 22:38:11 -05001831 &ev->surface->frame_callback_list);
1832 wl_list_init(&ev->surface->frame_callback_list);
Pekka Paalanene67858b2013-04-25 13:57:42 +03001833 }
1834 }
1835
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02001836 compositor_accumulate_damage(ec);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -04001837
Ander Conselvan de Oliveira4f521732012-08-15 14:02:05 -04001838 pixman_region32_init(&output_damage);
Ander Conselvan de Oliveira4f521732012-08-15 14:02:05 -04001839 pixman_region32_intersect(&output_damage,
1840 &ec->primary_plane.damage, &output->region);
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02001841 pixman_region32_subtract(&output_damage,
1842 &output_damage, &ec->primary_plane.clip);
Ander Conselvan de Oliveira4f521732012-08-15 14:02:05 -04001843
Scott Moreauccbf29d2012-02-22 14:21:41 -07001844 if (output->dirty)
1845 weston_output_update_matrix(output);
1846
David Herrmann1edf44c2013-10-22 17:11:26 +02001847 r = output->repaint(output, &output_damage);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001848
Kristian Høgsberg6ddcdae2012-02-28 22:31:58 -05001849 pixman_region32_fini(&output_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001850
Kristian Høgsbergef044142011-06-21 15:02:12 -04001851 output->repaint_needed = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001852
Kristian Høgsbergaa6019e2012-03-11 16:35:16 -04001853 weston_compositor_repick(ec);
1854 wl_event_loop_dispatch(ec->input_loop, 0);
1855
Jonas Ådahldb773762012-06-13 00:01:21 +02001856 wl_list_for_each_safe(cb, cnext, &frame_callback_list, link) {
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05001857 wl_callback_send_done(cb->resource, msecs);
1858 wl_resource_destroy(cb->resource);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001859 }
1860
Scott Moreaud64cf212012-06-08 19:40:54 -06001861 wl_list_for_each_safe(animation, next, &output->animation_list, link) {
Scott Moreaud64cf212012-06-08 19:40:54 -06001862 animation->frame_counter++;
Scott Moreau94b0b0c2012-06-14 01:01:56 -06001863 animation->frame(animation, output, msecs);
Scott Moreaud64cf212012-06-08 19:40:54 -06001864 }
David Herrmann1edf44c2013-10-22 17:11:26 +02001865
1866 return r;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001867}
Kristian Høgsbergb1868472011-04-22 12:27:57 -04001868
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001869static int
1870weston_compositor_read_input(int fd, uint32_t mask, void *data)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001871{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001872 struct weston_compositor *compositor = data;
Kristian Høgsberg34f80ff2012-01-18 11:50:31 -05001873
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001874 wl_event_loop_dispatch(compositor->input_loop, 0);
1875
1876 return 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001877}
1878
1879WL_EXPORT void
Rob Bradford0fb79752012-08-02 15:36:57 +01001880weston_output_finish_frame(struct weston_output *output, uint32_t msecs)
Kristian Høgsbergef044142011-06-21 15:02:12 -04001881{
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001882 struct weston_compositor *compositor = output->compositor;
1883 struct wl_event_loop *loop =
1884 wl_display_get_event_loop(compositor->wl_display);
David Herrmann1edf44c2013-10-22 17:11:26 +02001885 int fd, r;
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001886
Kristian Høgsberge9d04922012-06-19 23:54:26 -04001887 output->frame_time = msecs;
Kristian Høgsberg991810c2013-10-16 11:10:12 -07001888
1889 if (output->repaint_needed &&
1890 compositor->state != WESTON_COMPOSITOR_SLEEPING &&
1891 compositor->state != WESTON_COMPOSITOR_OFFSCREEN) {
David Herrmann1edf44c2013-10-22 17:11:26 +02001892 r = weston_output_repaint(output, msecs);
1893 if (!r)
1894 return;
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001895 }
1896
1897 output->repaint_scheduled = 0;
1898 if (compositor->input_loop_source)
1899 return;
1900
1901 fd = wl_event_loop_get_fd(compositor->input_loop);
1902 compositor->input_loop_source =
1903 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
1904 weston_compositor_read_input, compositor);
1905}
1906
1907static void
1908idle_repaint(void *data)
1909{
1910 struct weston_output *output = data;
1911
Jonas Ådahle5a12252013-04-05 23:07:11 +02001912 output->start_repaint_loop(output);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001913}
1914
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001915WL_EXPORT void
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001916weston_layer_init(struct weston_layer *layer, struct wl_list *below)
1917{
Jason Ekstranda7af7042013-10-12 22:38:11 -05001918 wl_list_init(&layer->view_list);
Jonas Ådahle3cddce2012-06-13 00:01:22 +02001919 if (below != NULL)
1920 wl_list_insert(below, &layer->link);
Kristian Høgsberg3be2ce92012-02-29 12:42:35 -05001921}
1922
1923WL_EXPORT void
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001924weston_output_schedule_repaint(struct weston_output *output)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001925{
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001926 struct weston_compositor *compositor = output->compositor;
Kristian Høgsbergef044142011-06-21 15:02:12 -04001927 struct wl_event_loop *loop;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001928
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01001929 if (compositor->state == WESTON_COMPOSITOR_SLEEPING ||
1930 compositor->state == WESTON_COMPOSITOR_OFFSCREEN)
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001931 return;
1932
Kristian Høgsbergef044142011-06-21 15:02:12 -04001933 loop = wl_display_get_event_loop(compositor->wl_display);
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001934 output->repaint_needed = 1;
1935 if (output->repaint_scheduled)
1936 return;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +01001937
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001938 wl_event_loop_add_idle(loop, idle_repaint, output);
1939 output->repaint_scheduled = 1;
Kristian Høgsberg7dbf5e22012-03-05 19:50:08 -05001940
1941 if (compositor->input_loop_source) {
1942 wl_event_source_remove(compositor->input_loop_source);
1943 compositor->input_loop_source = NULL;
1944 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04001945}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -05001946
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001947WL_EXPORT void
Kristian Høgsberg49952d12012-06-20 00:35:59 -04001948weston_compositor_schedule_repaint(struct weston_compositor *compositor)
1949{
1950 struct weston_output *output;
1951
1952 wl_list_for_each(output, &compositor->output_list, link)
1953 weston_output_schedule_repaint(output);
1954}
1955
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001956static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001957surface_destroy(struct wl_client *client, struct wl_resource *resource)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001958{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04001959 wl_resource_destroy(resource);
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001960}
1961
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001962static void
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001963surface_attach(struct wl_client *client,
1964 struct wl_resource *resource,
1965 struct wl_resource *buffer_resource, int32_t sx, int32_t sy)
1966{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05001967 struct weston_surface *surface = wl_resource_get_user_data(resource);
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001968 struct weston_buffer *buffer = NULL;
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001969
Kristian Høgsbergab19f932013-08-20 11:30:54 -07001970 if (buffer_resource) {
Jason Ekstrand6bd62942013-06-20 20:38:23 -05001971 buffer = weston_buffer_from_resource(buffer_resource);
Kristian Høgsbergab19f932013-08-20 11:30:54 -07001972 if (buffer == NULL) {
1973 wl_client_post_no_memory(client);
1974 return;
1975 }
Kristian Høgsberg08b58c72013-08-15 12:26:42 -07001976 }
Kristian Høgsberga691aee2011-06-23 21:43:50 -04001977
Pekka Paalanende685b82012-12-04 15:58:12 +02001978 /* Attach, attach, without commit in between does not send
1979 * wl_buffer.release. */
Jason Ekstrand7b982072014-05-20 14:33:03 -05001980 weston_surface_state_set_buffer(&surface->pending, buffer);
Ander Conselvan de Oliveirae11683a2012-03-27 17:36:40 +03001981
Pekka Paalanen5df44de2012-10-10 12:49:23 +03001982 surface->pending.sx = sx;
1983 surface->pending.sy = sy;
Giulio Camuffo184df502013-02-21 11:29:21 +01001984 surface->pending.newly_attached = 1;
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001985}
1986
Kristian Høgsberg5503bf82008-11-06 10:38:17 -05001987static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001988surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001989 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001990 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -05001991{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05001992 struct weston_surface *surface = wl_resource_get_user_data(resource);
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -04001993
Pekka Paalanen8e159182012-10-10 12:49:25 +03001994 pixman_region32_union_rect(&surface->pending.damage,
1995 &surface->pending.damage,
Kristian Høgsberg460a79b2012-06-18 15:09:11 -04001996 x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001997}
1998
Kristian Høgsberg33418202011-08-16 23:01:28 -04001999static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -04002000destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04002001{
Jason Ekstrandfbbbec82013-06-14 10:07:57 -05002002 struct weston_frame_callback *cb = wl_resource_get_user_data(resource);
Kristian Høgsberg904055a2011-08-18 17:55:30 -04002003
2004 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02002005 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04002006}
2007
2008static void
2009surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04002010 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04002011{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002012 struct weston_frame_callback *cb;
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002013 struct weston_surface *surface = wl_resource_get_user_data(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04002014
2015 cb = malloc(sizeof *cb);
2016 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04002017 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04002018 return;
2019 }
Pekka Paalanenbc106382012-10-10 12:49:31 +03002020
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07002021 cb->resource = wl_resource_create(client, &wl_callback_interface, 1,
2022 callback);
2023 if (cb->resource == NULL) {
2024 free(cb);
2025 wl_resource_post_no_memory(resource);
2026 return;
2027 }
2028
Jason Ekstranda85118c2013-06-27 20:17:02 -05002029 wl_resource_set_implementation(cb->resource, NULL, cb,
2030 destroy_frame_callback);
Kristian Høgsberg33418202011-08-16 23:01:28 -04002031
Pekka Paalanenbc106382012-10-10 12:49:31 +03002032 wl_list_insert(surface->pending.frame_callback_list.prev, &cb->link);
Kristian Høgsberg33418202011-08-16 23:01:28 -04002033}
2034
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002035static void
2036surface_set_opaque_region(struct wl_client *client,
2037 struct wl_resource *resource,
2038 struct wl_resource *region_resource)
2039{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002040 struct weston_surface *surface = wl_resource_get_user_data(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002041 struct weston_region *region;
2042
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002043 if (region_resource) {
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002044 region = wl_resource_get_user_data(region_resource);
Pekka Paalanen512dde82012-10-10 12:49:27 +03002045 pixman_region32_copy(&surface->pending.opaque,
2046 &region->region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002047 } else {
Jason Ekstrandef540082014-06-26 10:37:36 -07002048 pixman_region32_clear(&surface->pending.opaque);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002049 }
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002050}
2051
2052static void
2053surface_set_input_region(struct wl_client *client,
2054 struct wl_resource *resource,
2055 struct wl_resource *region_resource)
2056{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002057 struct weston_surface *surface = wl_resource_get_user_data(resource);
Kristian Høgsberg010f98b2012-02-23 17:30:45 -05002058 struct weston_region *region;
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002059
2060 if (region_resource) {
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002061 region = wl_resource_get_user_data(region_resource);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002062 pixman_region32_copy(&surface->pending.input,
2063 &region->region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002064 } else {
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002065 pixman_region32_fini(&surface->pending.input);
2066 region_init_infinite(&surface->pending.input);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002067 }
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002068}
2069
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002070static void
Pekka Paalanene67858b2013-04-25 13:57:42 +03002071weston_surface_commit_subsurface_order(struct weston_surface *surface)
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002072{
Pekka Paalanene67858b2013-04-25 13:57:42 +03002073 struct weston_subsurface *sub;
2074
2075 wl_list_for_each_reverse(sub, &surface->subsurface_list_pending,
2076 parent_link_pending) {
2077 wl_list_remove(&sub->parent_link);
2078 wl_list_insert(&surface->subsurface_list, &sub->parent_link);
2079 }
2080}
2081
2082static void
Jason Ekstrand7b982072014-05-20 14:33:03 -05002083weston_surface_commit_state(struct weston_surface *surface,
2084 struct weston_surface_state *state)
Pekka Paalanene67858b2013-04-25 13:57:42 +03002085{
Jason Ekstranda7af7042013-10-12 22:38:11 -05002086 struct weston_view *view;
Ander Conselvan de Oliveira5df8eca2012-10-30 17:44:01 +02002087 pixman_region32_t opaque;
2088
Alexander Larsson4ea95522013-05-22 14:41:37 +02002089 /* wl_surface.set_buffer_transform */
Alexander Larsson4ea95522013-05-22 14:41:37 +02002090 /* wl_surface.set_buffer_scale */
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02002091 /* wl_viewport.set */
Jason Ekstrand7b982072014-05-20 14:33:03 -05002092 surface->buffer_viewport = state->buffer_viewport;
Alexander Larsson4ea95522013-05-22 14:41:37 +02002093
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002094 /* wl_surface.attach */
Jason Ekstrand7b982072014-05-20 14:33:03 -05002095 if (state->newly_attached)
2096 weston_surface_attach(surface, state->buffer);
2097 weston_surface_state_set_buffer(state, NULL);
Giulio Camuffo184df502013-02-21 11:29:21 +01002098
Jason Ekstrand7b982072014-05-20 14:33:03 -05002099 if (state->newly_attached || state->buffer_viewport.changed) {
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02002100 weston_surface_update_size(surface);
2101 if (surface->configure)
Jason Ekstrand7b982072014-05-20 14:33:03 -05002102 surface->configure(surface, state->sx, state->sy);
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02002103 }
Giulio Camuffo184df502013-02-21 11:29:21 +01002104
Jason Ekstrand7b982072014-05-20 14:33:03 -05002105 state->sx = 0;
2106 state->sy = 0;
2107 state->newly_attached = 0;
2108 state->buffer_viewport.changed = 0;
Pekka Paalanen8e159182012-10-10 12:49:25 +03002109
2110 /* wl_surface.damage */
2111 pixman_region32_union(&surface->damage, &surface->damage,
Jason Ekstrand7b982072014-05-20 14:33:03 -05002112 &state->damage);
Kristian Høgsberg4d0214c2012-11-08 11:36:02 -05002113 pixman_region32_intersect_rect(&surface->damage, &surface->damage,
Jason Ekstrandef540082014-06-26 10:37:36 -07002114 0, 0, surface->width, surface->height);
2115 pixman_region32_clear(&surface->pending.damage);
Pekka Paalanen512dde82012-10-10 12:49:27 +03002116
2117 /* wl_surface.set_opaque_region */
Jason Ekstrand7b982072014-05-20 14:33:03 -05002118 pixman_region32_init(&opaque);
2119 pixman_region32_intersect_rect(&opaque, &state->opaque,
2120 0, 0, surface->width, surface->height);
Ander Conselvan de Oliveira5df8eca2012-10-30 17:44:01 +02002121
2122 if (!pixman_region32_equal(&opaque, &surface->opaque)) {
2123 pixman_region32_copy(&surface->opaque, &opaque);
Jason Ekstranda7af7042013-10-12 22:38:11 -05002124 wl_list_for_each(view, &surface->views, surface_link)
2125 weston_view_geometry_dirty(view);
Ander Conselvan de Oliveira5df8eca2012-10-30 17:44:01 +02002126 }
2127
2128 pixman_region32_fini(&opaque);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002129
2130 /* wl_surface.set_input_region */
Jason Ekstrand7b982072014-05-20 14:33:03 -05002131 pixman_region32_intersect_rect(&surface->input, &state->input,
2132 0, 0, surface->width, surface->height);
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002133
Pekka Paalanenbc106382012-10-10 12:49:31 +03002134 /* wl_surface.frame */
2135 wl_list_insert_list(&surface->frame_callback_list,
Jason Ekstrand7b982072014-05-20 14:33:03 -05002136 &state->frame_callback_list);
2137 wl_list_init(&state->frame_callback_list);
2138}
2139
2140static void
2141weston_surface_commit(struct weston_surface *surface)
2142{
2143 weston_surface_commit_state(surface, &surface->pending);
Pekka Paalanenbc106382012-10-10 12:49:31 +03002144
Pekka Paalanene67858b2013-04-25 13:57:42 +03002145 weston_surface_commit_subsurface_order(surface);
2146
Pekka Paalanen0cbd3b52012-10-10 12:49:28 +03002147 weston_surface_schedule_repaint(surface);
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002148}
2149
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002150static void
Pekka Paalanene67858b2013-04-25 13:57:42 +03002151weston_subsurface_commit(struct weston_subsurface *sub);
2152
2153static void
2154weston_subsurface_parent_commit(struct weston_subsurface *sub,
2155 int parent_is_synchronized);
2156
2157static void
2158surface_commit(struct wl_client *client, struct wl_resource *resource)
2159{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002160 struct weston_surface *surface = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002161 struct weston_subsurface *sub = weston_surface_to_subsurface(surface);
2162
2163 if (sub) {
2164 weston_subsurface_commit(sub);
2165 return;
2166 }
2167
2168 weston_surface_commit(surface);
2169
2170 wl_list_for_each(sub, &surface->subsurface_list, parent_link) {
2171 if (sub->surface != surface)
2172 weston_subsurface_parent_commit(sub, 0);
2173 }
2174}
2175
2176static void
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002177surface_set_buffer_transform(struct wl_client *client,
2178 struct wl_resource *resource, int transform)
2179{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002180 struct weston_surface *surface = wl_resource_get_user_data(resource);
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002181
Jonny Lamba55f1392014-05-30 12:07:15 +02002182 /* if wl_output.transform grows more members this will need to be updated. */
2183 if (transform < 0 ||
2184 transform > WL_OUTPUT_TRANSFORM_FLIPPED_270) {
2185 wl_resource_post_error(resource,
2186 WL_SURFACE_ERROR_INVALID_TRANSFORM,
2187 "buffer transform must be a valid transform "
2188 "('%d' specified)", transform);
2189 return;
2190 }
2191
Pekka Paalanen952b6c82014-03-14 14:38:15 +02002192 surface->pending.buffer_viewport.buffer.transform = transform;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02002193 surface->pending.buffer_viewport.changed = 1;
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002194}
2195
Alexander Larsson4ea95522013-05-22 14:41:37 +02002196static void
2197surface_set_buffer_scale(struct wl_client *client,
2198 struct wl_resource *resource,
Alexander Larssonedddbd12013-05-24 13:09:43 +02002199 int32_t scale)
Alexander Larsson4ea95522013-05-22 14:41:37 +02002200{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002201 struct weston_surface *surface = wl_resource_get_user_data(resource);
Alexander Larsson4ea95522013-05-22 14:41:37 +02002202
Jonny Lamba55f1392014-05-30 12:07:15 +02002203 if (scale < 1) {
2204 wl_resource_post_error(resource,
2205 WL_SURFACE_ERROR_INVALID_SCALE,
2206 "buffer scale must be at least one "
2207 "('%d' specified)", scale);
2208 return;
2209 }
2210
Pekka Paalanen952b6c82014-03-14 14:38:15 +02002211 surface->pending.buffer_viewport.buffer.scale = scale;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02002212 surface->pending.buffer_viewport.changed = 1;
Alexander Larsson4ea95522013-05-22 14:41:37 +02002213}
2214
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04002215static const struct wl_surface_interface surface_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002216 surface_destroy,
2217 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04002218 surface_damage,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002219 surface_frame,
2220 surface_set_opaque_region,
Pekka Paalanen5df44de2012-10-10 12:49:23 +03002221 surface_set_input_region,
Ander Conselvan de Oliveira012b4c72012-11-27 17:03:42 +02002222 surface_commit,
Alexander Larsson4ea95522013-05-22 14:41:37 +02002223 surface_set_buffer_transform,
2224 surface_set_buffer_scale
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002225};
2226
2227static void
2228compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04002229 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002230{
Kristian Høgsbergc2d70422013-06-25 15:34:33 -04002231 struct weston_compositor *ec = wl_resource_get_user_data(resource);
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002232 struct weston_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002233
Kristian Høgsberg18c93002012-01-27 11:58:31 -05002234 surface = weston_surface_create(ec);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04002235 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04002236 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002237 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04002238 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002239
Jason Ekstranda85118c2013-06-27 20:17:02 -05002240 surface->resource =
2241 wl_resource_create(client, &wl_surface_interface,
2242 wl_resource_get_version(resource), id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07002243 if (surface->resource == NULL) {
2244 weston_surface_destroy(surface);
2245 wl_resource_post_no_memory(resource);
2246 return;
2247 }
Jason Ekstranda85118c2013-06-27 20:17:02 -05002248 wl_resource_set_implementation(surface->resource, &surface_interface,
2249 surface, destroy_surface);
Kristian Høgsbergf03a04a2014-04-06 22:04:50 -07002250
2251 wl_signal_emit(&ec->create_surface_signal, surface);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002252}
2253
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002254static void
2255destroy_region(struct wl_resource *resource)
2256{
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002257 struct weston_region *region = wl_resource_get_user_data(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002258
2259 pixman_region32_fini(&region->region);
2260 free(region);
2261}
2262
2263static void
2264region_destroy(struct wl_client *client, struct wl_resource *resource)
2265{
Kristian Høgsbergeae5de72012-04-11 22:42:15 -04002266 wl_resource_destroy(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002267}
2268
2269static void
2270region_add(struct wl_client *client, struct wl_resource *resource,
2271 int32_t x, int32_t y, int32_t width, int32_t height)
2272{
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002273 struct weston_region *region = wl_resource_get_user_data(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002274
2275 pixman_region32_union_rect(&region->region, &region->region,
2276 x, y, width, height);
2277}
2278
2279static void
2280region_subtract(struct wl_client *client, struct wl_resource *resource,
2281 int32_t x, int32_t y, int32_t width, int32_t height)
2282{
Jason Ekstrand8895efc2013-06-14 10:07:56 -05002283 struct weston_region *region = wl_resource_get_user_data(resource);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002284 pixman_region32_t rect;
2285
2286 pixman_region32_init_rect(&rect, x, y, width, height);
2287 pixman_region32_subtract(&region->region, &region->region, &rect);
2288 pixman_region32_fini(&rect);
2289}
2290
2291static const struct wl_region_interface region_interface = {
2292 region_destroy,
2293 region_add,
2294 region_subtract
2295};
2296
2297static void
2298compositor_create_region(struct wl_client *client,
2299 struct wl_resource *resource, uint32_t id)
2300{
2301 struct weston_region *region;
2302
2303 region = malloc(sizeof *region);
2304 if (region == NULL) {
2305 wl_resource_post_no_memory(resource);
2306 return;
2307 }
2308
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002309 pixman_region32_init(&region->region);
2310
Jason Ekstranda85118c2013-06-27 20:17:02 -05002311 region->resource =
2312 wl_resource_create(client, &wl_region_interface, 1, id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07002313 if (region->resource == NULL) {
2314 free(region);
2315 wl_resource_post_no_memory(resource);
2316 return;
2317 }
Jason Ekstranda85118c2013-06-27 20:17:02 -05002318 wl_resource_set_implementation(region->resource, &region_interface,
2319 region, destroy_region);
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002320}
2321
Kristian Høgsberg875ab9e2012-03-30 11:52:39 -04002322static const struct wl_compositor_interface compositor_interface = {
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002323 compositor_create_surface,
Kristian Høgsberg5e7e6f22012-02-23 16:11:59 -05002324 compositor_create_region
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05002325};
2326
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002327static void
Pekka Paalanene67858b2013-04-25 13:57:42 +03002328weston_subsurface_commit_from_cache(struct weston_subsurface *sub)
2329{
2330 struct weston_surface *surface = sub->surface;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002331
Jason Ekstrand7b982072014-05-20 14:33:03 -05002332 weston_surface_commit_state(surface, &sub->cached);
2333 weston_buffer_reference(&sub->cached_buffer_ref, NULL);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002334
2335 weston_surface_commit_subsurface_order(surface);
2336
2337 weston_surface_schedule_repaint(surface);
2338
Jason Ekstrand7b982072014-05-20 14:33:03 -05002339 sub->has_cached_data = 0;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002340}
2341
2342static void
2343weston_subsurface_commit_to_cache(struct weston_subsurface *sub)
2344{
2345 struct weston_surface *surface = sub->surface;
2346
2347 /*
2348 * If this commit would cause the surface to move by the
2349 * attach(dx, dy) parameters, the old damage region must be
2350 * translated to correspond to the new surface coordinate system
Hardening57388e42013-09-18 23:56:36 +02002351 * original_mode.
Pekka Paalanene67858b2013-04-25 13:57:42 +03002352 */
2353 pixman_region32_translate(&sub->cached.damage,
2354 -surface->pending.sx, -surface->pending.sy);
2355 pixman_region32_union(&sub->cached.damage, &sub->cached.damage,
2356 &surface->pending.damage);
Jason Ekstrandef540082014-06-26 10:37:36 -07002357 pixman_region32_clear(&surface->pending.damage);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002358
2359 if (surface->pending.newly_attached) {
2360 sub->cached.newly_attached = 1;
Jason Ekstrand7b982072014-05-20 14:33:03 -05002361 weston_surface_state_set_buffer(&sub->cached,
2362 surface->pending.buffer);
2363 weston_buffer_reference(&sub->cached_buffer_ref,
Pekka Paalanene67858b2013-04-25 13:57:42 +03002364 surface->pending.buffer);
2365 }
2366 sub->cached.sx += surface->pending.sx;
2367 sub->cached.sy += surface->pending.sy;
Pekka Paalanen260ba382014-03-14 14:38:12 +02002368
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02002369 sub->cached.buffer_viewport.changed |=
2370 surface->pending.buffer_viewport.changed;
2371 sub->cached.buffer_viewport.buffer =
2372 surface->pending.buffer_viewport.buffer;
2373 sub->cached.buffer_viewport.surface =
2374 surface->pending.buffer_viewport.surface;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002375
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02002376 weston_surface_reset_pending_buffer(surface);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002377
2378 pixman_region32_copy(&sub->cached.opaque, &surface->pending.opaque);
2379
2380 pixman_region32_copy(&sub->cached.input, &surface->pending.input);
2381
2382 wl_list_insert_list(&sub->cached.frame_callback_list,
2383 &surface->pending.frame_callback_list);
2384 wl_list_init(&surface->pending.frame_callback_list);
2385
Jason Ekstrand7b982072014-05-20 14:33:03 -05002386 sub->has_cached_data = 1;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002387}
2388
2389static int
2390weston_subsurface_is_synchronized(struct weston_subsurface *sub)
2391{
2392 while (sub) {
2393 if (sub->synchronized)
2394 return 1;
2395
2396 if (!sub->parent)
2397 return 0;
2398
2399 sub = weston_surface_to_subsurface(sub->parent);
2400 }
2401
2402 return 0;
2403}
2404
2405static void
2406weston_subsurface_commit(struct weston_subsurface *sub)
2407{
2408 struct weston_surface *surface = sub->surface;
2409 struct weston_subsurface *tmp;
2410
2411 /* Recursive check for effectively synchronized. */
2412 if (weston_subsurface_is_synchronized(sub)) {
2413 weston_subsurface_commit_to_cache(sub);
2414 } else {
Jason Ekstrand7b982072014-05-20 14:33:03 -05002415 if (sub->has_cached_data) {
Pekka Paalanene67858b2013-04-25 13:57:42 +03002416 /* flush accumulated state from cache */
2417 weston_subsurface_commit_to_cache(sub);
2418 weston_subsurface_commit_from_cache(sub);
2419 } else {
2420 weston_surface_commit(surface);
2421 }
2422
2423 wl_list_for_each(tmp, &surface->subsurface_list, parent_link) {
2424 if (tmp->surface != surface)
2425 weston_subsurface_parent_commit(tmp, 0);
2426 }
2427 }
2428}
2429
2430static void
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002431weston_subsurface_synchronized_commit(struct weston_subsurface *sub)
Pekka Paalanene67858b2013-04-25 13:57:42 +03002432{
2433 struct weston_surface *surface = sub->surface;
2434 struct weston_subsurface *tmp;
2435
Pekka Paalanene67858b2013-04-25 13:57:42 +03002436 /* From now on, commit_from_cache the whole sub-tree, regardless of
2437 * the synchronized mode of each child. This sub-surface or some
2438 * of its ancestors were synchronized, so we are synchronized
2439 * all the way down.
2440 */
2441
Jason Ekstrand7b982072014-05-20 14:33:03 -05002442 if (sub->has_cached_data)
Pekka Paalanene67858b2013-04-25 13:57:42 +03002443 weston_subsurface_commit_from_cache(sub);
2444
2445 wl_list_for_each(tmp, &surface->subsurface_list, parent_link) {
2446 if (tmp->surface != surface)
2447 weston_subsurface_parent_commit(tmp, 1);
2448 }
2449}
2450
2451static void
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002452weston_subsurface_parent_commit(struct weston_subsurface *sub,
2453 int parent_is_synchronized)
2454{
Jason Ekstranda7af7042013-10-12 22:38:11 -05002455 struct weston_view *view;
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002456 if (sub->position.set) {
Jason Ekstranda7af7042013-10-12 22:38:11 -05002457 wl_list_for_each(view, &sub->surface->views, surface_link)
2458 weston_view_set_position(view,
2459 sub->position.x,
2460 sub->position.y);
2461
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002462 sub->position.set = 0;
2463 }
2464
2465 if (parent_is_synchronized || sub->synchronized)
2466 weston_subsurface_synchronized_commit(sub);
2467}
2468
2469static void
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06002470subsurface_configure(struct weston_surface *surface, int32_t dx, int32_t dy)
Pekka Paalanene67858b2013-04-25 13:57:42 +03002471{
2472 struct weston_compositor *compositor = surface->compositor;
Jason Ekstranda7af7042013-10-12 22:38:11 -05002473 struct weston_view *view;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002474
Jason Ekstranda7af7042013-10-12 22:38:11 -05002475 wl_list_for_each(view, &surface->views, surface_link)
Jason Ekstrand918f2dd2013-12-02 21:01:53 -06002476 weston_view_set_position(view,
2477 view->geometry.x + dx,
2478 view->geometry.y + dy);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002479
2480 /* No need to check parent mappedness, because if parent is not
2481 * mapped, parent is not in a visible layer, so this sub-surface
2482 * will not be drawn either.
2483 */
2484 if (!weston_surface_is_mapped(surface)) {
Pekka Paalanene67858b2013-04-25 13:57:42 +03002485 /* Cannot call weston_surface_update_transform(),
2486 * because that would call it also for the parent surface,
2487 * which might not be mapped yet. That would lead to
2488 * inconsistent state, where the window could never be
2489 * mapped.
2490 *
2491 * Instead just assing any output, to make
2492 * weston_surface_is_mapped() return true, so that when the
2493 * parent surface does get mapped, this one will get
2494 * included, too. See surface_list_add().
2495 */
2496 assert(!wl_list_empty(&compositor->output_list));
2497 surface->output = container_of(compositor->output_list.next,
2498 struct weston_output, link);
2499 }
2500}
2501
2502static struct weston_subsurface *
2503weston_surface_to_subsurface(struct weston_surface *surface)
2504{
2505 if (surface->configure == subsurface_configure)
2506 return surface->configure_private;
2507
2508 return NULL;
2509}
2510
Pekka Paalanen01388e22013-04-25 13:57:44 +03002511WL_EXPORT struct weston_surface *
2512weston_surface_get_main_surface(struct weston_surface *surface)
2513{
2514 struct weston_subsurface *sub;
2515
2516 while (surface && (sub = weston_surface_to_subsurface(surface)))
2517 surface = sub->parent;
2518
2519 return surface;
2520}
2521
Pekka Paalanene67858b2013-04-25 13:57:42 +03002522static void
2523subsurface_set_position(struct wl_client *client,
2524 struct wl_resource *resource, int32_t x, int32_t y)
2525{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002526 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002527
2528 if (!sub)
2529 return;
2530
2531 sub->position.x = x;
2532 sub->position.y = y;
2533 sub->position.set = 1;
2534}
2535
2536static struct weston_subsurface *
2537subsurface_from_surface(struct weston_surface *surface)
2538{
2539 struct weston_subsurface *sub;
2540
2541 sub = weston_surface_to_subsurface(surface);
2542 if (sub)
2543 return sub;
2544
2545 wl_list_for_each(sub, &surface->subsurface_list, parent_link)
2546 if (sub->surface == surface)
2547 return sub;
2548
2549 return NULL;
2550}
2551
2552static struct weston_subsurface *
2553subsurface_sibling_check(struct weston_subsurface *sub,
2554 struct weston_surface *surface,
2555 const char *request)
2556{
2557 struct weston_subsurface *sibling;
2558
2559 sibling = subsurface_from_surface(surface);
2560
2561 if (!sibling) {
2562 wl_resource_post_error(sub->resource,
2563 WL_SUBSURFACE_ERROR_BAD_SURFACE,
2564 "%s: wl_surface@%d is not a parent or sibling",
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002565 request, wl_resource_get_id(surface->resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002566 return NULL;
2567 }
2568
2569 if (sibling->parent != sub->parent) {
2570 wl_resource_post_error(sub->resource,
2571 WL_SUBSURFACE_ERROR_BAD_SURFACE,
2572 "%s: wl_surface@%d has a different parent",
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002573 request, wl_resource_get_id(surface->resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002574 return NULL;
2575 }
2576
2577 return sibling;
2578}
2579
2580static void
2581subsurface_place_above(struct wl_client *client,
2582 struct wl_resource *resource,
2583 struct wl_resource *sibling_resource)
2584{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002585 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002586 struct weston_surface *surface =
2587 wl_resource_get_user_data(sibling_resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002588 struct weston_subsurface *sibling;
2589
2590 if (!sub)
2591 return;
2592
2593 sibling = subsurface_sibling_check(sub, surface, "place_above");
2594 if (!sibling)
2595 return;
2596
2597 wl_list_remove(&sub->parent_link_pending);
2598 wl_list_insert(sibling->parent_link_pending.prev,
2599 &sub->parent_link_pending);
2600}
2601
2602static void
2603subsurface_place_below(struct wl_client *client,
2604 struct wl_resource *resource,
2605 struct wl_resource *sibling_resource)
2606{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002607 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002608 struct weston_surface *surface =
2609 wl_resource_get_user_data(sibling_resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002610 struct weston_subsurface *sibling;
2611
2612 if (!sub)
2613 return;
2614
2615 sibling = subsurface_sibling_check(sub, surface, "place_below");
2616 if (!sibling)
2617 return;
2618
2619 wl_list_remove(&sub->parent_link_pending);
2620 wl_list_insert(&sibling->parent_link_pending,
2621 &sub->parent_link_pending);
2622}
2623
2624static void
2625subsurface_set_sync(struct wl_client *client, struct wl_resource *resource)
2626{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002627 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002628
2629 if (sub)
2630 sub->synchronized = 1;
2631}
2632
2633static void
2634subsurface_set_desync(struct wl_client *client, struct wl_resource *resource)
2635{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002636 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002637
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002638 if (sub && sub->synchronized) {
Pekka Paalanene67858b2013-04-25 13:57:42 +03002639 sub->synchronized = 0;
Pekka Paalanen16abf6a2013-05-17 16:46:05 +03002640
2641 /* If sub became effectively desynchronized, flush. */
2642 if (!weston_subsurface_is_synchronized(sub))
2643 weston_subsurface_synchronized_commit(sub);
2644 }
Pekka Paalanene67858b2013-04-25 13:57:42 +03002645}
2646
2647static void
Pekka Paalanene67858b2013-04-25 13:57:42 +03002648weston_subsurface_unlink_parent(struct weston_subsurface *sub)
2649{
2650 wl_list_remove(&sub->parent_link);
2651 wl_list_remove(&sub->parent_link_pending);
2652 wl_list_remove(&sub->parent_destroy_listener.link);
2653 sub->parent = NULL;
2654}
2655
2656static void
2657weston_subsurface_destroy(struct weston_subsurface *sub);
2658
2659static void
2660subsurface_handle_surface_destroy(struct wl_listener *listener, void *data)
2661{
2662 struct weston_subsurface *sub =
2663 container_of(listener, struct weston_subsurface,
2664 surface_destroy_listener);
2665 assert(data == &sub->surface->resource);
2666
2667 /* The protocol object (wl_resource) is left inert. */
2668 if (sub->resource)
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002669 wl_resource_set_user_data(sub->resource, NULL);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002670
2671 weston_subsurface_destroy(sub);
2672}
2673
2674static void
2675subsurface_handle_parent_destroy(struct wl_listener *listener, void *data)
2676{
2677 struct weston_subsurface *sub =
2678 container_of(listener, struct weston_subsurface,
2679 parent_destroy_listener);
2680 assert(data == &sub->parent->resource);
2681 assert(sub->surface != sub->parent);
2682
2683 if (weston_surface_is_mapped(sub->surface))
2684 weston_surface_unmap(sub->surface);
2685
2686 weston_subsurface_unlink_parent(sub);
2687}
2688
2689static void
2690subsurface_resource_destroy(struct wl_resource *resource)
2691{
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002692 struct weston_subsurface *sub = wl_resource_get_user_data(resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002693
2694 if (sub)
2695 weston_subsurface_destroy(sub);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002696}
2697
2698static void
2699subsurface_destroy(struct wl_client *client, struct wl_resource *resource)
2700{
2701 wl_resource_destroy(resource);
2702}
2703
2704static void
2705weston_subsurface_link_parent(struct weston_subsurface *sub,
2706 struct weston_surface *parent)
2707{
2708 sub->parent = parent;
2709 sub->parent_destroy_listener.notify = subsurface_handle_parent_destroy;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002710 wl_signal_add(&parent->destroy_signal,
Pekka Paalanene67858b2013-04-25 13:57:42 +03002711 &sub->parent_destroy_listener);
2712
2713 wl_list_insert(&parent->subsurface_list, &sub->parent_link);
2714 wl_list_insert(&parent->subsurface_list_pending,
2715 &sub->parent_link_pending);
2716}
2717
2718static void
2719weston_subsurface_link_surface(struct weston_subsurface *sub,
2720 struct weston_surface *surface)
2721{
2722 sub->surface = surface;
2723 sub->surface_destroy_listener.notify =
2724 subsurface_handle_surface_destroy;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002725 wl_signal_add(&surface->destroy_signal,
Pekka Paalanene67858b2013-04-25 13:57:42 +03002726 &sub->surface_destroy_listener);
2727}
2728
2729static void
2730weston_subsurface_destroy(struct weston_subsurface *sub)
2731{
Jason Ekstranda7af7042013-10-12 22:38:11 -05002732 struct weston_view *view, *next;
2733
Pekka Paalanene67858b2013-04-25 13:57:42 +03002734 assert(sub->surface);
2735
2736 if (sub->resource) {
2737 assert(weston_surface_to_subsurface(sub->surface) == sub);
2738 assert(sub->parent_destroy_listener.notify ==
2739 subsurface_handle_parent_destroy);
2740
George Kiagiadakised04d382014-06-13 18:10:26 +02002741 wl_list_for_each_safe(view, next, &sub->surface->views, surface_link) {
2742 weston_view_unmap(view);
Jason Ekstranda7af7042013-10-12 22:38:11 -05002743 weston_view_destroy(view);
George Kiagiadakised04d382014-06-13 18:10:26 +02002744 }
Jason Ekstranda7af7042013-10-12 22:38:11 -05002745
Pekka Paalanene67858b2013-04-25 13:57:42 +03002746 if (sub->parent)
2747 weston_subsurface_unlink_parent(sub);
2748
Jason Ekstrand7b982072014-05-20 14:33:03 -05002749 weston_surface_state_fini(&sub->cached);
2750 weston_buffer_reference(&sub->cached_buffer_ref, NULL);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002751
2752 sub->surface->configure = NULL;
2753 sub->surface->configure_private = NULL;
2754 } else {
2755 /* the dummy weston_subsurface for the parent itself */
2756 assert(sub->parent_destroy_listener.notify == NULL);
2757 wl_list_remove(&sub->parent_link);
2758 wl_list_remove(&sub->parent_link_pending);
2759 }
2760
2761 wl_list_remove(&sub->surface_destroy_listener.link);
2762 free(sub);
2763}
2764
2765static const struct wl_subsurface_interface subsurface_implementation = {
2766 subsurface_destroy,
2767 subsurface_set_position,
2768 subsurface_place_above,
2769 subsurface_place_below,
2770 subsurface_set_sync,
2771 subsurface_set_desync
2772};
2773
2774static struct weston_subsurface *
2775weston_subsurface_create(uint32_t id, struct weston_surface *surface,
2776 struct weston_surface *parent)
2777{
2778 struct weston_subsurface *sub;
Jason Ekstrand26ed73c2013-06-06 22:34:41 -05002779 struct wl_client *client = wl_resource_get_client(surface->resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002780
2781 sub = calloc(1, sizeof *sub);
2782 if (!sub)
2783 return NULL;
2784
Jason Ekstranda7af7042013-10-12 22:38:11 -05002785 wl_list_init(&sub->unused_views);
2786
Jason Ekstranda85118c2013-06-27 20:17:02 -05002787 sub->resource =
2788 wl_resource_create(client, &wl_subsurface_interface, 1, id);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002789 if (!sub->resource) {
2790 free(sub);
2791 return NULL;
2792 }
2793
Jason Ekstranda85118c2013-06-27 20:17:02 -05002794 wl_resource_set_implementation(sub->resource,
2795 &subsurface_implementation,
2796 sub, subsurface_resource_destroy);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002797 weston_subsurface_link_surface(sub, surface);
2798 weston_subsurface_link_parent(sub, parent);
Jason Ekstrand7b982072014-05-20 14:33:03 -05002799 weston_surface_state_init(&sub->cached);
2800 sub->cached_buffer_ref.buffer = NULL;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002801 sub->synchronized = 1;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002802
2803 return sub;
2804}
2805
2806/* Create a dummy subsurface for having the parent itself in its
2807 * sub-surface lists. Makes stacking order manipulation easy.
2808 */
2809static struct weston_subsurface *
2810weston_subsurface_create_for_parent(struct weston_surface *parent)
2811{
2812 struct weston_subsurface *sub;
2813
2814 sub = calloc(1, sizeof *sub);
2815 if (!sub)
2816 return NULL;
2817
2818 weston_subsurface_link_surface(sub, parent);
2819 sub->parent = parent;
2820 wl_list_insert(&parent->subsurface_list, &sub->parent_link);
2821 wl_list_insert(&parent->subsurface_list_pending,
2822 &sub->parent_link_pending);
2823
2824 return sub;
2825}
2826
2827static void
2828subcompositor_get_subsurface(struct wl_client *client,
2829 struct wl_resource *resource,
2830 uint32_t id,
2831 struct wl_resource *surface_resource,
2832 struct wl_resource *parent_resource)
2833{
Jason Ekstrand0f2ef7e2013-06-14 10:07:53 -05002834 struct weston_surface *surface =
2835 wl_resource_get_user_data(surface_resource);
2836 struct weston_surface *parent =
2837 wl_resource_get_user_data(parent_resource);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002838 struct weston_subsurface *sub;
2839 static const char where[] = "get_subsurface: wl_subsurface@";
2840
2841 if (surface == parent) {
2842 wl_resource_post_error(resource,
2843 WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
2844 "%s%d: wl_surface@%d cannot be its own parent",
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002845 where, id, wl_resource_get_id(surface_resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002846 return;
2847 }
2848
2849 if (weston_surface_to_subsurface(surface)) {
2850 wl_resource_post_error(resource,
2851 WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
2852 "%s%d: wl_surface@%d is already a sub-surface",
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002853 where, id, wl_resource_get_id(surface_resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002854 return;
2855 }
2856
2857 if (surface->configure) {
2858 wl_resource_post_error(resource,
2859 WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
2860 "%s%d: wl_surface@%d already has a role",
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002861 where, id, wl_resource_get_id(surface_resource));
Pekka Paalanene67858b2013-04-25 13:57:42 +03002862 return;
2863 }
2864
Pekka Paalanen86c8ca02013-05-17 16:46:07 +03002865 if (weston_surface_get_main_surface(parent) == surface) {
2866 wl_resource_post_error(resource,
2867 WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
2868 "%s%d: wl_surface@%d is an ancestor of parent",
Jason Ekstrand0bd587e2013-06-14 10:08:02 -05002869 where, id, wl_resource_get_id(surface_resource));
Pekka Paalanen86c8ca02013-05-17 16:46:07 +03002870 return;
2871 }
2872
Pekka Paalanene67858b2013-04-25 13:57:42 +03002873 /* make sure the parent is in its own list */
2874 if (wl_list_empty(&parent->subsurface_list)) {
2875 if (!weston_subsurface_create_for_parent(parent)) {
2876 wl_resource_post_no_memory(resource);
2877 return;
2878 }
2879 }
2880
2881 sub = weston_subsurface_create(id, surface, parent);
2882 if (!sub) {
2883 wl_resource_post_no_memory(resource);
2884 return;
2885 }
2886
2887 surface->configure = subsurface_configure;
2888 surface->configure_private = sub;
2889}
2890
2891static void
2892subcompositor_destroy(struct wl_client *client, struct wl_resource *resource)
2893{
2894 wl_resource_destroy(resource);
2895}
2896
2897static const struct wl_subcompositor_interface subcompositor_interface = {
2898 subcompositor_destroy,
2899 subcompositor_get_subsurface
2900};
2901
2902static void
2903bind_subcompositor(struct wl_client *client,
2904 void *data, uint32_t version, uint32_t id)
2905{
2906 struct weston_compositor *compositor = data;
Jason Ekstranda85118c2013-06-27 20:17:02 -05002907 struct wl_resource *resource;
Pekka Paalanene67858b2013-04-25 13:57:42 +03002908
Jason Ekstranda85118c2013-06-27 20:17:02 -05002909 resource =
2910 wl_resource_create(client, &wl_subcompositor_interface, 1, id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07002911 if (resource == NULL) {
2912 wl_client_post_no_memory(client);
2913 return;
2914 }
2915 wl_resource_set_implementation(resource, &subcompositor_interface,
2916 compositor, NULL);
Pekka Paalanene67858b2013-04-25 13:57:42 +03002917}
2918
2919static void
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002920weston_compositor_dpms(struct weston_compositor *compositor,
2921 enum dpms_enum state)
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002922{
2923 struct weston_output *output;
2924
2925 wl_list_for_each(output, &compositor->output_list, link)
2926 if (output->set_dpms)
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002927 output->set_dpms(output, state);
Tiago Vignatti8e53c7f2012-02-29 19:53:50 +02002928}
2929
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02002930WL_EXPORT void
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002931weston_compositor_wake(struct weston_compositor *compositor)
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02002932{
Neil Roberts8b62e202013-09-30 13:14:47 +01002933 uint32_t old_state = compositor->state;
2934
2935 /* The state needs to be changed before emitting the wake
2936 * signal because that may try to schedule a repaint which
2937 * will not work if the compositor is still sleeping */
2938 compositor->state = WESTON_COMPOSITOR_ACTIVE;
2939
2940 switch (old_state) {
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002941 case WESTON_COMPOSITOR_SLEEPING:
2942 weston_compositor_dpms(compositor, WESTON_DPMS_ON);
2943 /* fall through */
2944 case WESTON_COMPOSITOR_IDLE:
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002945 case WESTON_COMPOSITOR_OFFSCREEN:
Ander Conselvan de Oliveiraa4575632013-02-21 18:35:23 +02002946 wl_signal_emit(&compositor->wake_signal, compositor);
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002947 /* fall through */
2948 default:
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002949 wl_event_source_timer_update(compositor->idle_source,
2950 compositor->idle_time * 1000);
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02002951 }
2952}
2953
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002954WL_EXPORT void
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002955weston_compositor_offscreen(struct weston_compositor *compositor)
2956{
2957 switch (compositor->state) {
2958 case WESTON_COMPOSITOR_OFFSCREEN:
2959 return;
2960 case WESTON_COMPOSITOR_SLEEPING:
2961 weston_compositor_dpms(compositor, WESTON_DPMS_ON);
2962 /* fall through */
2963 default:
2964 compositor->state = WESTON_COMPOSITOR_OFFSCREEN;
2965 wl_event_source_timer_update(compositor->idle_source, 0);
2966 }
2967}
2968
2969WL_EXPORT void
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002970weston_compositor_sleep(struct weston_compositor *compositor)
2971{
2972 if (compositor->state == WESTON_COMPOSITOR_SLEEPING)
2973 return;
2974
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01002975 wl_event_source_timer_update(compositor->idle_source, 0);
Ander Conselvan de Oliveira87524b62013-02-21 18:35:22 +02002976 compositor->state = WESTON_COMPOSITOR_SLEEPING;
2977 weston_compositor_dpms(compositor, WESTON_DPMS_OFF);
2978}
2979
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002980static int
2981idle_handler(void *data)
2982{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05002983 struct weston_compositor *compositor = data;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002984
2985 if (compositor->idle_inhibit)
2986 return 1;
2987
Ander Conselvan de Oliveira19d10ef2013-02-21 18:35:20 +02002988 compositor->state = WESTON_COMPOSITOR_IDLE;
Ander Conselvan de Oliveiraa4575632013-02-21 18:35:23 +02002989 wl_signal_emit(&compositor->idle_signal, compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002990
2991 return 1;
2992}
2993
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04002994WL_EXPORT void
Xiong Zhang97116532013-10-23 13:58:31 +08002995weston_plane_init(struct weston_plane *plane,
2996 struct weston_compositor *ec,
2997 int32_t x, int32_t y)
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04002998{
2999 pixman_region32_init(&plane->damage);
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02003000 pixman_region32_init(&plane->clip);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003001 plane->x = x;
3002 plane->y = y;
Xiong Zhang97116532013-10-23 13:58:31 +08003003 plane->compositor = ec;
Ander Conselvan de Oliveira3c36bf32013-07-05 16:05:26 +03003004
3005 /* Init the link so that the call to wl_list_remove() when releasing
3006 * the plane without ever stacking doesn't lead to a crash */
3007 wl_list_init(&plane->link);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003008}
3009
3010WL_EXPORT void
3011weston_plane_release(struct weston_plane *plane)
3012{
Xiong Zhang97116532013-10-23 13:58:31 +08003013 struct weston_view *view;
3014
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003015 pixman_region32_fini(&plane->damage);
Ander Conselvan de Oliveirae1bd5a02013-03-05 17:30:29 +02003016 pixman_region32_fini(&plane->clip);
Ander Conselvan de Oliveira3c36bf32013-07-05 16:05:26 +03003017
Xiong Zhang97116532013-10-23 13:58:31 +08003018 wl_list_for_each(view, &plane->compositor->view_list, link) {
3019 if (view->plane == plane)
3020 view->plane = NULL;
3021 }
3022
Ander Conselvan de Oliveira3c36bf32013-07-05 16:05:26 +03003023 wl_list_remove(&plane->link);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003024}
3025
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02003026WL_EXPORT void
3027weston_compositor_stack_plane(struct weston_compositor *ec,
3028 struct weston_plane *plane,
3029 struct weston_plane *above)
3030{
3031 if (above)
3032 wl_list_insert(above->link.prev, &plane->link);
3033 else
3034 wl_list_insert(&ec->plane_list, &plane->link);
3035}
3036
Casey Dahlin9074db52012-04-19 22:50:09 -04003037static void unbind_resource(struct wl_resource *resource)
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04003038{
Jason Ekstranda0d2dde2013-06-14 10:08:01 -05003039 wl_list_remove(wl_resource_get_link(resource));
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04003040}
3041
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04003042static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04003043bind_output(struct wl_client *client,
3044 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05003045{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003046 struct weston_output *output = data;
3047 struct weston_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04003048 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05003049
Jason Ekstranda85118c2013-06-27 20:17:02 -05003050 resource = wl_resource_create(client, &wl_output_interface,
3051 MIN(version, 2), id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07003052 if (resource == NULL) {
3053 wl_client_post_no_memory(client);
3054 return;
3055 }
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04003056
Jason Ekstranda0d2dde2013-06-14 10:08:01 -05003057 wl_list_insert(&output->resource_list, wl_resource_get_link(resource));
Jason Ekstranda85118c2013-06-27 20:17:02 -05003058 wl_resource_set_implementation(resource, NULL, data, unbind_resource);
Casey Dahlin9074db52012-04-19 22:50:09 -04003059
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05003060 wl_output_send_geometry(resource,
3061 output->x,
3062 output->y,
3063 output->mm_width,
3064 output->mm_height,
3065 output->subpixel,
Kristian Høgsberg0e696472012-07-22 15:49:57 -04003066 output->make, output->model,
Kristian Høgsberg05890dc2012-08-10 10:09:20 -04003067 output->transform);
Alexander Larsson4ea95522013-05-22 14:41:37 +02003068 if (version >= 2)
3069 wl_output_send_scale(resource,
Hardeningff39efa2013-09-18 23:56:35 +02003070 output->current_scale);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04003071
3072 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsberg0b5cd0c2012-03-04 21:57:37 -05003073 wl_output_send_mode(resource,
3074 mode->flags,
3075 mode->width,
3076 mode->height,
3077 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04003078 }
Alexander Larsson4ea95522013-05-22 14:41:37 +02003079
3080 if (version >= 2)
3081 wl_output_send_done(resource);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05003082}
3083
Zhang, Xiong Ya4b54c02013-12-13 22:10:51 +02003084/* Move other outputs when one is removed so the space remains contiguos. */
3085static void
3086weston_compositor_remove_output(struct weston_compositor *compositor,
3087 struct weston_output *remove_output)
3088{
3089 struct weston_output *output;
3090 int offset = 0;
3091
3092 wl_list_for_each(output, &compositor->output_list, link) {
3093 if (output == remove_output) {
3094 offset = output->width;
3095 continue;
3096 }
3097
3098 if (offset > 0) {
3099 weston_output_move(output,
3100 output->x - offset, output->y);
3101 output->dirty = 1;
3102 }
3103 }
3104}
3105
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003106WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003107weston_output_destroy(struct weston_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003108{
Ander Conselvan de Oliveirae1e23522013-12-13 22:10:55 +02003109 output->destroying = 1;
3110
Zhang, Xiong Ya4b54c02013-12-13 22:10:51 +02003111 weston_compositor_remove_output(output->compositor, output);
Ander Conselvan de Oliveiraf749fc32013-12-13 22:10:50 +02003112 wl_list_remove(&output->link);
3113
Ander Conselvan de Oliveiraf84327a2014-01-29 18:47:51 +02003114 wl_signal_emit(&output->compositor->output_destroyed_signal, output);
Richard Hughes64ddde12013-05-01 21:52:10 +01003115 wl_signal_emit(&output->destroy_signal, output);
3116
Richard Hughesafe690c2013-05-02 10:10:04 +01003117 free(output->name);
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04003118 pixman_region32_fini(&output->region);
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +02003119 pixman_region32_fini(&output->previous_damage);
Casey Dahlin9074db52012-04-19 22:50:09 -04003120 output->compositor->output_id_pool &= ~(1 << output->id);
Benjamin Franzkeb6879402012-04-10 18:28:54 +02003121
Kristian Høgsberg919cddb2013-07-08 19:03:57 -04003122 wl_global_destroy(output->global);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003123}
3124
Scott Moreau1bad5db2012-08-18 01:04:05 -06003125static void
3126weston_output_compute_transform(struct weston_output *output)
3127{
3128 struct weston_matrix transform;
3129 int flip;
3130
3131 weston_matrix_init(&transform);
Vasily Khoruzhick1bbf3722013-01-28 22:40:28 +03003132 transform.type = WESTON_MATRIX_TRANSFORM_ROTATE;
Scott Moreau1bad5db2012-08-18 01:04:05 -06003133
3134 switch(output->transform) {
3135 case WL_OUTPUT_TRANSFORM_FLIPPED:
3136 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
3137 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
3138 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
Vasily Khoruzhick1bbf3722013-01-28 22:40:28 +03003139 transform.type |= WESTON_MATRIX_TRANSFORM_OTHER;
Scott Moreau1bad5db2012-08-18 01:04:05 -06003140 flip = -1;
3141 break;
3142 default:
3143 flip = 1;
3144 break;
3145 }
3146
3147 switch(output->transform) {
3148 case WL_OUTPUT_TRANSFORM_NORMAL:
3149 case WL_OUTPUT_TRANSFORM_FLIPPED:
3150 transform.d[0] = flip;
3151 transform.d[1] = 0;
3152 transform.d[4] = 0;
3153 transform.d[5] = 1;
3154 break;
3155 case WL_OUTPUT_TRANSFORM_90:
3156 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
3157 transform.d[0] = 0;
3158 transform.d[1] = -flip;
3159 transform.d[4] = 1;
3160 transform.d[5] = 0;
3161 break;
3162 case WL_OUTPUT_TRANSFORM_180:
3163 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
3164 transform.d[0] = -flip;
3165 transform.d[1] = 0;
3166 transform.d[4] = 0;
3167 transform.d[5] = -1;
3168 break;
3169 case WL_OUTPUT_TRANSFORM_270:
3170 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
3171 transform.d[0] = 0;
3172 transform.d[1] = flip;
3173 transform.d[4] = -1;
3174 transform.d[5] = 0;
3175 break;
3176 default:
3177 break;
3178 }
3179
3180 weston_matrix_multiply(&output->matrix, &transform);
3181}
3182
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003183WL_EXPORT void
Scott Moreauccbf29d2012-02-22 14:21:41 -07003184weston_output_update_matrix(struct weston_output *output)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003185{
Scott Moreau850ca422012-05-21 15:21:25 -06003186 float magnification;
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05003187
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003188 weston_matrix_init(&output->matrix);
3189 weston_matrix_translate(&output->matrix,
Jason Ekstrand00b84282013-10-27 22:24:59 -05003190 -(output->x + output->width / 2.0),
3191 -(output->y + output->height / 2.0), 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01003192
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003193 weston_matrix_scale(&output->matrix,
Jason Ekstrand00b84282013-10-27 22:24:59 -05003194 2.0 / output->width,
3195 -2.0 / output->height, 1);
Scott Moreau1bad5db2012-08-18 01:04:05 -06003196
Scott Moreauccbf29d2012-02-22 14:21:41 -07003197 if (output->zoom.active) {
Scott Moreaue6603982012-06-11 13:07:51 -06003198 magnification = 1 / (1 - output->zoom.spring_z.current);
Jason Ekstranda7af7042013-10-12 22:38:11 -05003199 weston_output_update_zoom(output);
Neil Roberts1e40a7e2014-04-25 13:19:37 +01003200 weston_matrix_translate(&output->matrix, -output->zoom.trans_x,
3201 output->zoom.trans_y, 0);
3202 weston_matrix_scale(&output->matrix, magnification,
3203 magnification, 1.0);
Scott Moreauccbf29d2012-02-22 14:21:41 -07003204 }
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003205
Neil Roberts6c3b01f2014-05-06 19:04:15 +01003206 weston_output_compute_transform(output);
3207
Scott Moreauccbf29d2012-02-22 14:21:41 -07003208 output->dirty = 0;
3209}
3210
Scott Moreau1bad5db2012-08-18 01:04:05 -06003211static void
Alexander Larsson0b135062013-05-28 16:23:36 +02003212weston_output_transform_scale_init(struct weston_output *output, uint32_t transform, uint32_t scale)
Scott Moreau1bad5db2012-08-18 01:04:05 -06003213{
3214 output->transform = transform;
3215
3216 switch (transform) {
3217 case WL_OUTPUT_TRANSFORM_90:
3218 case WL_OUTPUT_TRANSFORM_270:
3219 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
3220 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
3221 /* Swap width and height */
Hardeningff39efa2013-09-18 23:56:35 +02003222 output->width = output->current_mode->height;
3223 output->height = output->current_mode->width;
Scott Moreau1bad5db2012-08-18 01:04:05 -06003224 break;
3225 case WL_OUTPUT_TRANSFORM_NORMAL:
3226 case WL_OUTPUT_TRANSFORM_180:
3227 case WL_OUTPUT_TRANSFORM_FLIPPED:
3228 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
Hardeningff39efa2013-09-18 23:56:35 +02003229 output->width = output->current_mode->width;
3230 output->height = output->current_mode->height;
Scott Moreau1bad5db2012-08-18 01:04:05 -06003231 break;
3232 default:
3233 break;
3234 }
Scott Moreau1bad5db2012-08-18 01:04:05 -06003235
Hardening57388e42013-09-18 23:56:36 +02003236 output->native_scale = output->current_scale = scale;
Alexander Larsson0b135062013-05-28 16:23:36 +02003237 output->width /= scale;
3238 output->height /= scale;
Alexander Larsson4ea95522013-05-22 14:41:37 +02003239}
3240
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003241static void
3242weston_output_init_geometry(struct weston_output *output, int x, int y)
Scott Moreauccbf29d2012-02-22 14:21:41 -07003243{
3244 output->x = x;
3245 output->y = y;
3246
Ander Conselvan de Oliveirab8fcca92012-11-16 17:23:52 +02003247 pixman_region32_init(&output->previous_damage);
Scott Moreauccbf29d2012-02-22 14:21:41 -07003248 pixman_region32_init_rect(&output->region, x, y,
Scott Moreau1bad5db2012-08-18 01:04:05 -06003249 output->width,
3250 output->height);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003251}
3252
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003253WL_EXPORT void
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003254weston_output_move(struct weston_output *output, int x, int y)
3255{
3256 pixman_region32_t old_region;
3257 struct wl_resource *resource;
3258
3259 output->move_x = x - output->x;
3260 output->move_y = y - output->y;
3261
3262 if (output->move_x == 0 && output->move_y == 0)
3263 return;
3264
3265 pixman_region32_init(&old_region);
3266 pixman_region32_copy(&old_region, &output->region);
3267
3268 weston_output_init_geometry(output, x, y);
3269
3270 output->dirty = 1;
3271
3272 /* Move views on this output. */
Ander Conselvan de Oliveiraa8a9baf2014-01-29 18:47:52 +02003273 wl_signal_emit(&output->compositor->output_moved_signal, output);
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003274
3275 /* Notify clients of the change for output position. */
Quanxian Wangb2c86362014-03-14 09:16:25 +08003276 wl_resource_for_each(resource, &output->resource_list) {
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003277 wl_output_send_geometry(resource,
3278 output->x,
3279 output->y,
3280 output->mm_width,
3281 output->mm_height,
3282 output->subpixel,
3283 output->make,
3284 output->model,
3285 output->transform);
Quanxian Wangb2c86362014-03-14 09:16:25 +08003286
3287 if (wl_resource_get_version(resource) >= 2)
3288 wl_output_send_done(resource);
3289 }
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003290}
3291
3292WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003293weston_output_init(struct weston_output *output, struct weston_compositor *c,
Alexander Larsson0b135062013-05-28 16:23:36 +02003294 int x, int y, int mm_width, int mm_height, uint32_t transform,
Alexander Larssonedddbd12013-05-24 13:09:43 +02003295 int32_t scale)
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003296{
3297 output->compositor = c;
3298 output->x = x;
3299 output->y = y;
Alexander Larsson0b135062013-05-28 16:23:36 +02003300 output->mm_width = mm_width;
3301 output->mm_height = mm_height;
Scott Moreauccbf29d2012-02-22 14:21:41 -07003302 output->dirty = 1;
Hardeningff39efa2013-09-18 23:56:35 +02003303 output->original_scale = scale;
Scott Moreauccbf29d2012-02-22 14:21:41 -07003304
Alexander Larsson0b135062013-05-28 16:23:36 +02003305 weston_output_transform_scale_init(output, transform, scale);
Scott Moreau429490d2012-06-17 18:10:59 -06003306 weston_output_init_zoom(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003307
Zhang, Xiong Yf3012412013-12-13 22:10:53 +02003308 weston_output_init_geometry(output, x, y);
Benjamin Franzke78db8482012-04-10 18:35:33 +02003309 weston_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01003310
Kristian Høgsberg5fb70bf2012-05-24 12:29:46 -04003311 wl_signal_init(&output->frame_signal);
Richard Hughes64ddde12013-05-01 21:52:10 +01003312 wl_signal_init(&output->destroy_signal);
Scott Moreau9d1b1122012-06-08 19:40:53 -06003313 wl_list_init(&output->animation_list);
Casey Dahlin9074db52012-04-19 22:50:09 -04003314 wl_list_init(&output->resource_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02003315
Casey Dahlin58ba1372012-04-19 22:50:08 -04003316 output->id = ffs(~output->compositor->output_id_pool) - 1;
3317 output->compositor->output_id_pool |= 1 << output->id;
3318
Benjamin Franzkeb6879402012-04-10 18:28:54 +02003319 output->global =
Kristian Høgsberg919cddb2013-07-08 19:03:57 -04003320 wl_global_create(c->wl_display, &wl_output_interface, 2,
3321 output, bind_output);
Richard Hughes59d5da72013-05-01 21:52:11 +01003322 wl_signal_emit(&c->output_created_signal, output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003323}
3324
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003325WL_EXPORT void
3326weston_output_transform_coordinate(struct weston_output *output,
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003327 wl_fixed_t device_x, wl_fixed_t device_y,
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003328 wl_fixed_t *x, wl_fixed_t *y)
3329{
3330 wl_fixed_t tx, ty;
3331 wl_fixed_t width, height;
Neil Robertseb5a2002014-05-01 16:13:55 +01003332 float zoom_scale, zx, zy;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003333
Hardeningff39efa2013-09-18 23:56:35 +02003334 width = wl_fixed_from_int(output->width * output->current_scale - 1);
3335 height = wl_fixed_from_int(output->height * output->current_scale - 1);
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003336
3337 switch(output->transform) {
3338 case WL_OUTPUT_TRANSFORM_NORMAL:
3339 default:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003340 tx = device_x;
3341 ty = device_y;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003342 break;
3343 case WL_OUTPUT_TRANSFORM_90:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003344 tx = device_y;
3345 ty = height - device_x;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003346 break;
3347 case WL_OUTPUT_TRANSFORM_180:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003348 tx = width - device_x;
3349 ty = height - device_y;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003350 break;
3351 case WL_OUTPUT_TRANSFORM_270:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003352 tx = width - device_y;
3353 ty = device_x;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003354 break;
3355 case WL_OUTPUT_TRANSFORM_FLIPPED:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003356 tx = width - device_x;
3357 ty = device_y;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003358 break;
3359 case WL_OUTPUT_TRANSFORM_FLIPPED_90:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003360 tx = width - device_y;
3361 ty = height - device_x;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003362 break;
3363 case WL_OUTPUT_TRANSFORM_FLIPPED_180:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003364 tx = device_x;
3365 ty = height - device_y;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003366 break;
3367 case WL_OUTPUT_TRANSFORM_FLIPPED_270:
Jason Ekstrandb6a3cc72013-10-27 22:25:00 -05003368 tx = device_y;
3369 ty = device_x;
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003370 break;
3371 }
3372
Neil Robertseb5a2002014-05-01 16:13:55 +01003373 tx /= output->current_scale;
3374 ty /= output->current_scale;
3375
3376 if (output->zoom.active) {
3377 zoom_scale = output->zoom.spring_z.current;
3378 zx = (wl_fixed_to_double(tx) * (1.0f - zoom_scale) +
3379 output->width / 2.0f *
3380 (zoom_scale + output->zoom.trans_x));
3381 zy = (wl_fixed_to_double(ty) * (1.0f - zoom_scale) +
3382 output->height / 2.0f *
3383 (zoom_scale + output->zoom.trans_y));
3384 tx = wl_fixed_from_double(zx);
3385 ty = wl_fixed_from_double(zy);
3386 }
3387
3388 *x = tx + wl_fixed_from_int(output->x);
3389 *y = ty + wl_fixed_from_int(output->y);
Kristian Høgsberg98c774f2013-07-22 14:33:42 -07003390}
3391
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01003392static void
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003393destroy_viewport(struct wl_resource *resource)
Jonny Lamb8ae35902013-11-26 18:19:45 +01003394{
Jonny Lamb74130762013-11-26 18:19:46 +01003395 struct weston_surface *surface =
3396 wl_resource_get_user_data(resource);
3397
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003398 surface->viewport_resource = NULL;
Pekka Paalanenf0cad482014-03-14 14:38:16 +02003399 surface->pending.buffer_viewport.buffer.src_width =
3400 wl_fixed_from_int(-1);
3401 surface->pending.buffer_viewport.surface.width = -1;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02003402 surface->pending.buffer_viewport.changed = 1;
Jonny Lamb8ae35902013-11-26 18:19:45 +01003403}
3404
3405static void
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003406viewport_destroy(struct wl_client *client,
3407 struct wl_resource *resource)
Jonny Lamb8ae35902013-11-26 18:19:45 +01003408{
3409 wl_resource_destroy(resource);
3410}
3411
3412static void
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003413viewport_set(struct wl_client *client,
3414 struct wl_resource *resource,
3415 wl_fixed_t src_x,
3416 wl_fixed_t src_y,
3417 wl_fixed_t src_width,
3418 wl_fixed_t src_height,
3419 int32_t dst_width,
3420 int32_t dst_height)
Jonny Lamb8ae35902013-11-26 18:19:45 +01003421{
Jonny Lamb74130762013-11-26 18:19:46 +01003422 struct weston_surface *surface =
3423 wl_resource_get_user_data(resource);
3424
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003425 assert(surface->viewport_resource != NULL);
Jonny Lamb74130762013-11-26 18:19:46 +01003426
Jonny Lamb8ae35902013-11-26 18:19:45 +01003427 if (wl_fixed_to_double(src_width) < 0 ||
3428 wl_fixed_to_double(src_height) < 0) {
3429 wl_resource_post_error(resource,
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003430 WL_VIEWPORT_ERROR_BAD_VALUE,
Jonny Lamb8ae35902013-11-26 18:19:45 +01003431 "source dimensions must be non-negative (%fx%f)",
3432 wl_fixed_to_double(src_width),
3433 wl_fixed_to_double(src_height));
3434 return;
3435 }
3436
3437 if (dst_width <= 0 || dst_height <= 0) {
3438 wl_resource_post_error(resource,
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003439 WL_VIEWPORT_ERROR_BAD_VALUE,
Jonny Lamb8ae35902013-11-26 18:19:45 +01003440 "destination dimensions must be positive (%dx%d)",
3441 dst_width, dst_height);
3442 return;
3443 }
3444
Pekka Paalanen952b6c82014-03-14 14:38:15 +02003445 surface->pending.buffer_viewport.buffer.src_x = src_x;
3446 surface->pending.buffer_viewport.buffer.src_y = src_y;
3447 surface->pending.buffer_viewport.buffer.src_width = src_width;
3448 surface->pending.buffer_viewport.buffer.src_height = src_height;
3449 surface->pending.buffer_viewport.surface.width = dst_width;
3450 surface->pending.buffer_viewport.surface.height = dst_height;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02003451 surface->pending.buffer_viewport.changed = 1;
Jonny Lamb8ae35902013-11-26 18:19:45 +01003452}
3453
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003454static void
3455viewport_set_source(struct wl_client *client,
3456 struct wl_resource *resource,
3457 wl_fixed_t src_x,
3458 wl_fixed_t src_y,
3459 wl_fixed_t src_width,
3460 wl_fixed_t src_height)
3461{
3462 struct weston_surface *surface =
3463 wl_resource_get_user_data(resource);
3464
3465 assert(surface->viewport_resource != NULL);
3466
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003467 if (src_width == wl_fixed_from_int(-1) &&
3468 src_height == wl_fixed_from_int(-1)) {
3469 /* unset source size */
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003470 surface->pending.buffer_viewport.buffer.src_width =
3471 wl_fixed_from_int(-1);
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02003472 surface->pending.buffer_viewport.changed = 1;
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003473 return;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003474 }
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003475
3476 if (src_width <= 0 || src_height <= 0) {
3477 wl_resource_post_error(resource,
3478 WL_VIEWPORT_ERROR_BAD_VALUE,
3479 "source size must be positive (%fx%f)",
3480 wl_fixed_to_double(src_width),
3481 wl_fixed_to_double(src_height));
3482 return;
3483 }
3484
3485 surface->pending.buffer_viewport.buffer.src_x = src_x;
3486 surface->pending.buffer_viewport.buffer.src_y = src_y;
3487 surface->pending.buffer_viewport.buffer.src_width = src_width;
3488 surface->pending.buffer_viewport.buffer.src_height = src_height;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02003489 surface->pending.buffer_viewport.changed = 1;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003490}
3491
3492static void
3493viewport_set_destination(struct wl_client *client,
3494 struct wl_resource *resource,
3495 int32_t dst_width,
3496 int32_t dst_height)
3497{
3498 struct weston_surface *surface =
3499 wl_resource_get_user_data(resource);
3500
3501 assert(surface->viewport_resource != NULL);
3502
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003503 if (dst_width == -1 && dst_height == -1) {
3504 /* unset destination size */
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003505 surface->pending.buffer_viewport.surface.width = -1;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02003506 surface->pending.buffer_viewport.changed = 1;
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003507 return;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003508 }
Pekka Paalanen2c8b5f52014-04-04 14:22:12 +03003509
3510 if (dst_width <= 0 || dst_height <= 0) {
3511 wl_resource_post_error(resource,
3512 WL_VIEWPORT_ERROR_BAD_VALUE,
3513 "destination size must be positive (%dx%d)",
3514 dst_width, dst_height);
3515 return;
3516 }
3517
3518 surface->pending.buffer_viewport.surface.width = dst_width;
3519 surface->pending.buffer_viewport.surface.height = dst_height;
George Kiagiadakis8f9e87f2014-06-13 18:14:20 +02003520 surface->pending.buffer_viewport.changed = 1;
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003521}
3522
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003523static const struct wl_viewport_interface viewport_interface = {
3524 viewport_destroy,
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003525 viewport_set,
3526 viewport_set_source,
3527 viewport_set_destination
Jonny Lamb8ae35902013-11-26 18:19:45 +01003528};
3529
3530static void
3531scaler_destroy(struct wl_client *client,
3532 struct wl_resource *resource)
3533{
3534 wl_resource_destroy(resource);
3535}
3536
3537static void
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003538scaler_get_viewport(struct wl_client *client,
3539 struct wl_resource *scaler,
3540 uint32_t id,
3541 struct wl_resource *surface_resource)
Jonny Lamb8ae35902013-11-26 18:19:45 +01003542{
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003543 int version = wl_resource_get_version(scaler);
3544 struct weston_surface *surface =
3545 wl_resource_get_user_data(surface_resource);
Jonny Lamb8ae35902013-11-26 18:19:45 +01003546 struct wl_resource *resource;
3547
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003548 if (surface->viewport_resource) {
Jonny Lamb74130762013-11-26 18:19:46 +01003549 wl_resource_post_error(scaler,
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003550 WL_SCALER_ERROR_VIEWPORT_EXISTS,
3551 "a viewport for that surface already exists");
Jonny Lamb74130762013-11-26 18:19:46 +01003552 return;
3553 }
3554
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003555 resource = wl_resource_create(client, &wl_viewport_interface,
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003556 version, id);
Jonny Lamb8ae35902013-11-26 18:19:45 +01003557 if (resource == NULL) {
3558 wl_client_post_no_memory(client);
3559 return;
3560 }
3561
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003562 wl_resource_set_implementation(resource, &viewport_interface,
3563 surface, destroy_viewport);
Jonny Lamb74130762013-11-26 18:19:46 +01003564
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003565 surface->viewport_resource = resource;
Jonny Lamb8ae35902013-11-26 18:19:45 +01003566}
3567
3568static const struct wl_scaler_interface scaler_interface = {
3569 scaler_destroy,
Pekka Paalanenb0420ae2014-01-08 15:39:17 +02003570 scaler_get_viewport
Jonny Lamb8ae35902013-11-26 18:19:45 +01003571};
3572
3573static void
3574bind_scaler(struct wl_client *client,
3575 void *data, uint32_t version, uint32_t id)
3576{
3577 struct wl_resource *resource;
3578
3579 resource = wl_resource_create(client, &wl_scaler_interface,
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003580 MIN(version, 2), id);
Jonny Lamb8ae35902013-11-26 18:19:45 +01003581 if (resource == NULL) {
3582 wl_client_post_no_memory(client);
3583 return;
3584 }
3585
3586 wl_resource_set_implementation(resource, &scaler_interface,
3587 NULL, NULL);
3588}
3589
3590static void
Kristian Høgsberga8873122011-11-23 10:39:34 -05003591compositor_bind(struct wl_client *client,
3592 void *data, uint32_t version, uint32_t id)
3593{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003594 struct weston_compositor *compositor = data;
Jason Ekstranda85118c2013-06-27 20:17:02 -05003595 struct wl_resource *resource;
Kristian Høgsberga8873122011-11-23 10:39:34 -05003596
Jason Ekstranda85118c2013-06-27 20:17:02 -05003597 resource = wl_resource_create(client, &wl_compositor_interface,
3598 MIN(version, 3), id);
Kristian Høgsberg0ff79082013-08-06 16:46:25 -07003599 if (resource == NULL) {
3600 wl_client_post_no_memory(client);
3601 return;
3602 }
3603
3604 wl_resource_set_implementation(resource, &compositor_interface,
3605 compositor, NULL);
Kristian Høgsberga8873122011-11-23 10:39:34 -05003606}
3607
Kristian Høgsbergfc9c5e02012-06-08 16:45:33 -04003608static void
Martin Minarikf12c2872012-06-11 00:57:39 +02003609log_uname(void)
3610{
3611 struct utsname usys;
3612
3613 uname(&usys);
3614
3615 weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release,
3616 usys.version, usys.machine);
3617}
3618
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003619WL_EXPORT int
Ander Conselvan de Oliveiracbdebc22013-02-21 18:35:16 +02003620weston_environment_get_fd(const char *env)
3621{
3622 char *e, *end;
3623 int fd, flags;
3624
3625 e = getenv(env);
3626 if (!e)
3627 return -1;
3628 fd = strtol(e, &end, 0);
3629 if (*end != '\0')
3630 return -1;
3631
3632 flags = fcntl(fd, F_GETFD);
3633 if (flags == -1)
3634 return -1;
3635
3636 fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
3637 unsetenv(env);
3638
3639 return fd;
3640}
3641
3642WL_EXPORT int
Daniel Stonebaf43592012-06-01 11:11:10 -04003643weston_compositor_init(struct weston_compositor *ec,
3644 struct wl_display *display,
Kristian Høgsberg4172f662013-02-20 15:27:49 -05003645 int *argc, char *argv[],
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04003646 struct weston_config *config)
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04003647{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05003648 struct wl_event_loop *loop;
Daniel Stonee2ef43a2012-06-01 12:14:05 +01003649 struct xkb_rule_names xkb_names;
Kristian Høgsberg6a047912013-05-23 15:56:29 -04003650 struct weston_config_section *s;
Ossama Othmana50e6e42013-05-14 09:48:26 -07003651
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04003652 ec->config = config;
Kristian Høgsbergf9212892008-10-11 18:40:23 -04003653 ec->wl_display = display;
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003654 wl_signal_init(&ec->destroy_signal);
Kristian Høgsbergf03a04a2014-04-06 22:04:50 -07003655 wl_signal_init(&ec->create_surface_signal);
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04003656 wl_signal_init(&ec->activate_signal);
Tiago Vignattifb2adba2013-06-12 15:43:21 -03003657 wl_signal_init(&ec->transform_signal);
Tiago Vignatti1d01b012012-09-27 17:48:36 +03003658 wl_signal_init(&ec->kill_signal);
Ander Conselvan de Oliveiraa4575632013-02-21 18:35:23 +02003659 wl_signal_init(&ec->idle_signal);
3660 wl_signal_init(&ec->wake_signal);
Jan Arne Petersen42feced2012-06-21 21:52:17 +02003661 wl_signal_init(&ec->show_input_panel_signal);
3662 wl_signal_init(&ec->hide_input_panel_signal);
Jan Arne Petersen14da96b2013-04-18 16:47:28 +02003663 wl_signal_init(&ec->update_input_panel_signal);
Jan Arne Petersen674fd1d2012-11-18 19:06:42 +01003664 wl_signal_init(&ec->seat_created_signal);
Richard Hughes59d5da72013-05-01 21:52:11 +01003665 wl_signal_init(&ec->output_created_signal);
Ander Conselvan de Oliveiraf84327a2014-01-29 18:47:51 +02003666 wl_signal_init(&ec->output_destroyed_signal);
Ander Conselvan de Oliveiraa8a9baf2014-01-29 18:47:52 +02003667 wl_signal_init(&ec->output_moved_signal);
Kristian Høgsberg61741a22013-09-17 16:02:57 -07003668 wl_signal_init(&ec->session_signal);
3669 ec->session_active = 1;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04003670
Casey Dahlin58ba1372012-04-19 22:50:08 -04003671 ec->output_id_pool = 0;
3672
Kristian Høgsberg919cddb2013-07-08 19:03:57 -04003673 if (!wl_global_create(display, &wl_compositor_interface, 3,
3674 ec, compositor_bind))
Kristian Høgsberga8873122011-11-23 10:39:34 -05003675 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05003676
Kristian Høgsberg919cddb2013-07-08 19:03:57 -04003677 if (!wl_global_create(display, &wl_subcompositor_interface, 1,
3678 ec, bind_subcompositor))
Pekka Paalanene67858b2013-04-25 13:57:42 +03003679 return -1;
3680
Pekka Paalanen0b4c5352014-03-14 14:38:17 +02003681 if (!wl_global_create(ec->wl_display, &wl_scaler_interface, 2,
Jonny Lamb8ae35902013-11-26 18:19:45 +01003682 ec, bind_scaler))
3683 return -1;
3684
Jason Ekstranda7af7042013-10-12 22:38:11 -05003685 wl_list_init(&ec->view_list);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02003686 wl_list_init(&ec->plane_list);
Daniel Stone725c2c32012-06-22 14:04:36 +01003687 wl_list_init(&ec->layer_list);
3688 wl_list_init(&ec->seat_list);
3689 wl_list_init(&ec->output_list);
3690 wl_list_init(&ec->key_binding_list);
Daniel Stone96d47c02013-11-19 11:37:12 +01003691 wl_list_init(&ec->modifier_binding_list);
Daniel Stone725c2c32012-06-22 14:04:36 +01003692 wl_list_init(&ec->button_binding_list);
Neil Robertsa28c6932013-10-03 16:43:04 +01003693 wl_list_init(&ec->touch_binding_list);
Daniel Stone725c2c32012-06-22 14:04:36 +01003694 wl_list_init(&ec->axis_binding_list);
Ander Conselvan de Oliveirac509d2b2012-11-08 17:20:45 +02003695 wl_list_init(&ec->debug_binding_list);
Daniel Stone725c2c32012-06-22 14:04:36 +01003696
Xiong Zhang97116532013-10-23 13:58:31 +08003697 weston_plane_init(&ec->primary_plane, ec, 0, 0);
Ander Conselvan de Oliveira8ad19822013-03-05 17:30:27 +02003698 weston_compositor_stack_plane(ec, &ec->primary_plane, NULL);
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003699
Kristian Høgsberg6a047912013-05-23 15:56:29 -04003700 s = weston_config_get_section(ec->config, "keyboard", NULL, NULL);
3701 weston_config_section_get_string(s, "keymap_rules",
3702 (char **) &xkb_names.rules, NULL);
3703 weston_config_section_get_string(s, "keymap_model",
3704 (char **) &xkb_names.model, NULL);
3705 weston_config_section_get_string(s, "keymap_layout",
3706 (char **) &xkb_names.layout, NULL);
3707 weston_config_section_get_string(s, "keymap_variant",
3708 (char **) &xkb_names.variant, NULL);
3709 weston_config_section_get_string(s, "keymap_options",
3710 (char **) &xkb_names.options, NULL);
Rob Bradford382ff462013-06-24 16:52:45 +01003711
Kristian Høgsberg2f07ef62013-02-16 14:29:24 -05003712 if (weston_compositor_xkb_init(ec, &xkb_names) < 0)
3713 return -1;
Daniel Stone725c2c32012-06-22 14:04:36 +01003714
Jan Arne Petersen674fd1d2012-11-18 19:06:42 +01003715 text_backend_init(ec);
Daniel Stone725c2c32012-06-22 14:04:36 +01003716
3717 wl_data_device_manager_init(ec->wl_display);
3718
Kristian Høgsberg9629fe32012-03-26 15:56:39 -04003719 wl_display_init_shm(display);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04003720
Daniel Stone725c2c32012-06-22 14:04:36 +01003721 loop = wl_display_get_event_loop(ec->wl_display);
3722 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
3723 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
3724
3725 ec->input_loop = wl_event_loop_create();
3726
Kristian Høgsberg861a50c2012-09-05 22:02:22 -04003727 weston_layer_init(&ec->fade_layer, &ec->layer_list);
3728 weston_layer_init(&ec->cursor_layer, &ec->fade_layer.link);
3729
3730 weston_compositor_schedule_repaint(ec);
3731
Daniel Stone725c2c32012-06-22 14:04:36 +01003732 return 0;
3733}
3734
Benjamin Franzkeb8263022011-08-30 11:32:47 +02003735WL_EXPORT void
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003736weston_compositor_shutdown(struct weston_compositor *ec)
Matt Roper361d2ad2011-08-29 13:52:23 -07003737{
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05003738 struct weston_output *output, *next;
Matt Roper361d2ad2011-08-29 13:52:23 -07003739
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003740 wl_event_source_remove(ec->idle_source);
Jonas Ådahlc97af922012-03-28 22:36:09 +02003741 if (ec->input_loop_source)
3742 wl_event_source_remove(ec->input_loop_source);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003743
Matt Roper361d2ad2011-08-29 13:52:23 -07003744 /* Destroy all outputs associated with this compositor */
Tiago Vignattib303a1d2011-12-18 22:27:40 +02003745 wl_list_for_each_safe(output, next, &ec->output_list, link)
Matt Roper361d2ad2011-08-29 13:52:23 -07003746 output->destroy(output);
Pekka Paalanen4738f3b2012-01-02 15:47:07 +02003747
Ander Conselvan de Oliveira18536762013-12-20 21:07:00 +02003748 if (ec->renderer)
3749 ec->renderer->destroy(ec);
3750
Daniel Stone325fc2d2012-05-30 16:31:58 +01003751 weston_binding_list_destroy_all(&ec->key_binding_list);
3752 weston_binding_list_destroy_all(&ec->button_binding_list);
Neil Robertsa28c6932013-10-03 16:43:04 +01003753 weston_binding_list_destroy_all(&ec->touch_binding_list);
Daniel Stone325fc2d2012-05-30 16:31:58 +01003754 weston_binding_list_destroy_all(&ec->axis_binding_list);
Ander Conselvan de Oliveirac509d2b2012-11-08 17:20:45 +02003755 weston_binding_list_destroy_all(&ec->debug_binding_list);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02003756
Kristian Høgsberg65a11e12012-08-03 11:30:18 -04003757 weston_plane_release(&ec->primary_plane);
3758
Jonas Ådahlc97af922012-03-28 22:36:09 +02003759 wl_event_loop_destroy(ec->input_loop);
Ossama Othmana50e6e42013-05-14 09:48:26 -07003760
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04003761 weston_config_destroy(ec->config);
Matt Roper361d2ad2011-08-29 13:52:23 -07003762}
3763
Kristian Høgsbergaf4f2aa2013-02-15 20:53:20 -05003764WL_EXPORT void
Giulio Camuffocdb4d292013-11-14 23:42:53 +01003765weston_compositor_set_default_pointer_grab(struct weston_compositor *ec,
3766 const struct weston_pointer_grab_interface *interface)
3767{
3768 struct weston_seat *seat;
3769
3770 ec->default_pointer_grab = interface;
3771 wl_list_for_each(seat, &ec->seat_list, link) {
3772 if (seat->pointer) {
3773 weston_pointer_set_default_grab(seat->pointer,
3774 interface);
3775 }
3776 }
3777}
3778
3779WL_EXPORT void
Kristian Høgsbergaf4f2aa2013-02-15 20:53:20 -05003780weston_version(int *major, int *minor, int *micro)
3781{
3782 *major = WESTON_VERSION_MAJOR;
3783 *minor = WESTON_VERSION_MINOR;
3784 *micro = WESTON_VERSION_MICRO;
3785}
3786
Pekka Paalanen7bb65102013-05-22 18:03:04 +03003787static const struct {
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +03003788 uint32_t bit; /* enum weston_capability */
Pekka Paalanen7bb65102013-05-22 18:03:04 +03003789 const char *desc;
3790} capability_strings[] = {
3791 { WESTON_CAP_ROTATION_ANY, "arbitrary surface rotation:" },
Pekka Paalanen4fc5dd02013-05-22 18:03:05 +03003792 { WESTON_CAP_CAPTURE_YFLIP, "screen capture uses y-flip:" },
Pekka Paalanen7bb65102013-05-22 18:03:04 +03003793};
3794
3795static void
3796weston_compositor_log_capabilities(struct weston_compositor *compositor)
3797{
3798 unsigned i;
3799 int yes;
3800
3801 weston_log("Compositor capabilities:\n");
3802 for (i = 0; i < ARRAY_LENGTH(capability_strings); i++) {
3803 yes = compositor->capabilities & capability_strings[i].bit;
3804 weston_log_continue(STAMP_SPACE "%s %s\n",
3805 capability_strings[i].desc,
3806 yes ? "yes" : "no");
3807 }
3808}
3809
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003810static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003811{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003812 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003813
Martin Minarik6d118362012-06-07 18:01:59 +02003814 weston_log("caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04003815 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04003816
3817 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05003818}
3819
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003820#ifdef HAVE_LIBUNWIND
3821
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003822static void
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003823print_backtrace(void)
3824{
3825 unw_cursor_t cursor;
3826 unw_context_t context;
3827 unw_word_t off;
3828 unw_proc_info_t pip;
3829 int ret, i = 0;
3830 char procname[256];
3831 const char *filename;
3832 Dl_info dlinfo;
3833
3834 pip.unwind_info = NULL;
3835 ret = unw_getcontext(&context);
3836 if (ret) {
3837 weston_log("unw_getcontext: %d\n", ret);
3838 return;
3839 }
3840
3841 ret = unw_init_local(&cursor, &context);
3842 if (ret) {
3843 weston_log("unw_init_local: %d\n", ret);
3844 return;
3845 }
3846
3847 ret = unw_step(&cursor);
3848 while (ret > 0) {
3849 ret = unw_get_proc_info(&cursor, &pip);
3850 if (ret) {
3851 weston_log("unw_get_proc_info: %d\n", ret);
3852 break;
3853 }
3854
3855 ret = unw_get_proc_name(&cursor, procname, 256, &off);
3856 if (ret && ret != -UNW_ENOMEM) {
3857 if (ret != -UNW_EUNSPEC)
3858 weston_log("unw_get_proc_name: %d\n", ret);
3859 procname[0] = '?';
3860 procname[1] = 0;
3861 }
3862
3863 if (dladdr((void *)(pip.start_ip + off), &dlinfo) && dlinfo.dli_fname &&
3864 *dlinfo.dli_fname)
3865 filename = dlinfo.dli_fname;
3866 else
3867 filename = "?";
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08003868
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003869 weston_log("%u: %s (%s%s+0x%x) [%p]\n", i++, filename, procname,
3870 ret == -UNW_ENOMEM ? "..." : "", (int)off, (void *)(pip.start_ip + off));
3871
3872 ret = unw_step(&cursor);
3873 if (ret < 0)
3874 weston_log("unw_step: %d\n", ret);
3875 }
3876}
3877
3878#else
3879
3880static void
3881print_backtrace(void)
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003882{
3883 void *buffer[32];
3884 int i, count;
3885 Dl_info info;
3886
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003887 count = backtrace(buffer, ARRAY_LENGTH(buffer));
3888 for (i = 0; i < count; i++) {
3889 dladdr(buffer[i], &info);
3890 weston_log(" [%016lx] %s (%s)\n",
3891 (long) buffer[i],
3892 info.dli_sname ? info.dli_sname : "--",
3893 info.dli_fname);
3894 }
3895}
3896
3897#endif
3898
3899static void
Peter Maatmane5b42e42013-03-27 22:38:53 +01003900on_caught_signal(int s, siginfo_t *siginfo, void *context)
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003901{
Peter Maatmane5b42e42013-03-27 22:38:53 +01003902 /* This signal handler will do a best-effort backtrace, and
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003903 * then call the backend restore function, which will switch
3904 * back to the vt we launched from or ungrab X etc and then
3905 * raise SIGTRAP. If we run weston under gdb from X or a
Peter Maatmane5b42e42013-03-27 22:38:53 +01003906 * different vt, and tell gdb "handle *s* nostop", this
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003907 * will allow weston to switch back to gdb on crash and then
Peter Maatmane5b42e42013-03-27 22:38:53 +01003908 * gdb will catch the crash with SIGTRAP.*/
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003909
Peter Maatmane5b42e42013-03-27 22:38:53 +01003910 weston_log("caught signal: %d\n", s);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003911
Marcin Slusarz554a0da2013-02-18 13:27:22 -05003912 print_backtrace();
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003913
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04003914 segv_compositor->restore(segv_compositor);
3915
3916 raise(SIGTRAP);
Kristian Høgsberg0690da62012-01-16 11:53:54 -05003917}
3918
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03003919WL_EXPORT void *
3920weston_load_module(const char *name, const char *entrypoint)
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003921{
3922 char path[PATH_MAX];
3923 void *module, *init;
3924
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08003925 if (name == NULL)
3926 return NULL;
3927
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003928 if (name[0] != '/')
Chad Versacebf381902012-05-23 23:42:15 -07003929 snprintf(path, sizeof path, "%s/%s", MODULEDIR, name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003930 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02003931 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003932
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003933 module = dlopen(path, RTLD_NOW | RTLD_NOLOAD);
3934 if (module) {
3935 weston_log("Module '%s' already loaded\n", path);
3936 dlclose(module);
3937 return NULL;
3938 }
3939
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003940 weston_log("Loading module '%s'\n", path);
Kristian Høgsberg1acd9f82012-07-26 11:39:26 -04003941 module = dlopen(path, RTLD_NOW);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003942 if (!module) {
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003943 weston_log("Failed to load module: %s\n", dlerror());
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003944 return NULL;
3945 }
3946
3947 init = dlsym(module, entrypoint);
3948 if (!init) {
Pekka Paalanen1b3c1ea2012-06-11 14:06:04 +03003949 weston_log("Failed to lookup init function: %s\n", dlerror());
Rob Bradfordc9e64ab2012-12-05 18:47:10 +00003950 dlclose(module);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04003951 return NULL;
3952 }
3953
3954 return init;
3955}
3956
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003957static int
Kristian Høgsbergcb4685b2013-02-20 15:37:49 -05003958load_modules(struct weston_compositor *ec, const char *modules,
Ossama Othmana50e6e42013-05-14 09:48:26 -07003959 int *argc, char *argv[])
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003960{
3961 const char *p, *end;
3962 char buffer[256];
Kristian Høgsbergcb4685b2013-02-20 15:37:49 -05003963 int (*module_init)(struct weston_compositor *ec,
Ossama Othmana50e6e42013-05-14 09:48:26 -07003964 int *argc, char *argv[]);
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003965
3966 if (modules == NULL)
3967 return 0;
3968
3969 p = modules;
3970 while (*p) {
3971 end = strchrnul(p, ',');
3972 snprintf(buffer, sizeof buffer, "%.*s", (int) (end - p), p);
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03003973 module_init = weston_load_module(buffer, "module_init");
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003974 if (module_init)
Ossama Othmana50e6e42013-05-14 09:48:26 -07003975 module_init(ec, argc, argv);
Kristian Høgsberga6813d22012-09-12 12:21:01 -04003976 p = end;
3977 while (*p == ',')
3978 p++;
3979
3980 }
3981
3982 return 0;
3983}
3984
Pekka Paalanen78a0b572012-06-06 16:59:44 +03003985static const char xdg_error_message[] =
Martin Minarik37032f82012-06-18 20:15:18 +02003986 "fatal: environment variable XDG_RUNTIME_DIR is not set.\n";
3987
3988static const char xdg_wrong_message[] =
3989 "fatal: environment variable XDG_RUNTIME_DIR\n"
3990 "is set to \"%s\", which is not a directory.\n";
3991
3992static const char xdg_wrong_mode_message[] =
3993 "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n"
Guillem Jover32b793c2014-01-31 20:41:21 +01003994 "correctly. Unix access mode must be 0700 (current mode is %o),\n"
3995 "and must be owned by the user (current owner is UID %d).\n";
Martin Minarik37032f82012-06-18 20:15:18 +02003996
3997static const char xdg_detail_message[] =
Pekka Paalanen78a0b572012-06-06 16:59:44 +03003998 "Refer to your distribution on how to get it, or\n"
3999 "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n"
4000 "on how to implement it.\n";
4001
Martin Minarik37032f82012-06-18 20:15:18 +02004002static void
4003verify_xdg_runtime_dir(void)
4004{
4005 char *dir = getenv("XDG_RUNTIME_DIR");
4006 struct stat s;
4007
4008 if (!dir) {
4009 weston_log(xdg_error_message);
4010 weston_log_continue(xdg_detail_message);
4011 exit(EXIT_FAILURE);
4012 }
4013
4014 if (stat(dir, &s) || !S_ISDIR(s.st_mode)) {
4015 weston_log(xdg_wrong_message, dir);
4016 weston_log_continue(xdg_detail_message);
4017 exit(EXIT_FAILURE);
4018 }
4019
4020 if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) {
4021 weston_log(xdg_wrong_mode_message,
4022 dir, s.st_mode & 0777, s.st_uid);
4023 weston_log_continue(xdg_detail_message);
4024 }
4025}
4026
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004027static int
4028usage(int error_code)
4029{
4030 fprintf(stderr,
4031 "Usage: weston [OPTIONS]\n\n"
4032 "This is weston version " VERSION ", the Wayland reference compositor.\n"
4033 "Weston supports multiple backends, and depending on which backend is in use\n"
4034 "different options will be accepted.\n\n"
4035
4036
4037 "Core options:\n\n"
Scott Moreau12245142012-08-29 15:15:58 -06004038 " --version\t\tPrint weston version\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004039 " -B, --backend=MODULE\tBackend module, one of drm-backend.so,\n"
Philipp Brüschweilere14560e2013-03-30 15:18:49 +01004040 "\t\t\t\tfbdev-backend.so, x11-backend.so or\n"
4041 "\t\t\t\twayland-backend.so\n"
Jason Ekstranda985da42013-08-22 17:28:03 -05004042 " --shell=MODULE\tShell module, defaults to desktop-shell.so\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004043 " -S, --socket=NAME\tName of socket to listen on\n"
4044 " -i, --idle-time=SECS\tIdle time in seconds\n"
Kristian Høgsberga6813d22012-09-12 12:21:01 -04004045 " --modules\t\tLoad the comma-separated list of modules\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004046 " --log==FILE\t\tLog to the given file\n"
Pekka Paalanen588bee12014-05-07 16:26:25 +03004047 " --no-config\t\tDo not read weston.ini\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004048 " -h, --help\t\tThis help message\n\n");
4049
4050 fprintf(stderr,
4051 "Options for drm-backend.so:\n\n"
4052 " --connector=ID\tBring up only this connector\n"
4053 " --seat=SEAT\t\tThe seat that weston should run on\n"
4054 " --tty=TTY\t\tThe tty to use\n"
Ander Conselvan de Oliveira23e72b82013-01-25 15:13:06 +02004055 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004056 " --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n");
4057
4058 fprintf(stderr,
Philipp Brüschweilere14560e2013-03-30 15:18:49 +01004059 "Options for fbdev-backend.so:\n\n"
4060 " --tty=TTY\t\tThe tty to use\n"
4061 " --device=DEVICE\tThe framebuffer device to use\n\n");
4062
4063 fprintf(stderr,
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004064 "Options for x11-backend.so:\n\n"
4065 " --width=WIDTH\t\tWidth of X window\n"
4066 " --height=HEIGHT\tHeight of X window\n"
4067 " --fullscreen\t\tRun in fullscreen mode\n"
Kristian Høgsbergefaca342013-01-07 15:52:44 -05004068 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004069 " --output-count=COUNT\tCreate multiple outputs\n"
4070 " --no-input\t\tDont create input devices\n\n");
4071
4072 fprintf(stderr,
4073 "Options for wayland-backend.so:\n\n"
4074 " --width=WIDTH\t\tWidth of Wayland surface\n"
4075 " --height=HEIGHT\tHeight of Wayland surface\n"
Jason Ekstrand12c6dd92013-11-07 20:13:32 -06004076 " --scale=SCALE\tScale factor of ouput\n"
Jason Ekstrand5ea04802013-11-07 20:13:33 -06004077 " --fullscreen\t\tRun in fullscreen mode\n"
Jason Ekstrandff2fd462013-10-27 22:24:58 -05004078 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
Jason Ekstrand48ce4212013-10-27 22:25:02 -05004079 " --output-count=COUNT\tCreate multiple outputs\n"
Jason Ekstrande4ca8b02014-04-02 19:53:55 -05004080 " --sprawl\t\tCreate one fullscreen output for every parent output\n"
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004081 " --display=DISPLAY\tWayland display to connect to\n\n");
4082
Pekka Paalanene31e0532013-05-22 18:03:07 +03004083#if defined(BUILD_RPI_COMPOSITOR) && defined(HAVE_BCM_HOST)
4084 fprintf(stderr,
4085 "Options for rpi-backend.so:\n\n"
4086 " --tty=TTY\t\tThe tty to use\n"
4087 " --single-buffer\tUse single-buffered Dispmanx elements.\n"
4088 " --transform=TR\tThe output transformation, TR is one of:\n"
4089 "\tnormal 90 180 270 flipped flipped-90 flipped-180 flipped-270\n"
Tomeu Vizosoe4f7b922013-12-02 17:18:58 +01004090 " --opaque-regions\tEnable support for opaque regions, can be "
4091 "very slow without support in the GPU firmware.\n"
Pekka Paalanene31e0532013-05-22 18:03:07 +03004092 "\n");
4093#endif
4094
Hardeningc077a842013-07-08 00:51:35 +02004095#if defined(BUILD_RDP_COMPOSITOR)
4096 fprintf(stderr,
4097 "Options for rdp-backend.so:\n\n"
4098 " --width=WIDTH\t\tWidth of desktop\n"
4099 " --height=HEIGHT\tHeight of desktop\n"
Hardeningc077a842013-07-08 00:51:35 +02004100 " --env-socket=SOCKET\tUse that socket as peer connection\n"
4101 " --address=ADDR\tThe address to bind\n"
4102 " --port=PORT\tThe port to listen on\n"
Hardeningf34cd2c2014-04-02 19:54:00 -05004103 " --no-clients-resize\tThe RDP peers will be forced to the size of the desktop\n"
Hardeningc077a842013-07-08 00:51:35 +02004104 " --rdp4-key=FILE\tThe file containing the key for RDP4 encryption\n"
4105 " --rdp-tls-cert=FILE\tThe file containing the certificate for TLS encryption\n"
4106 " --rdp-tls-key=FILE\tThe file containing the private key for TLS encryption\n"
4107 "\n");
4108#endif
4109
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004110 exit(error_code);
4111}
4112
Peter Maatmane5b42e42013-03-27 22:38:53 +01004113static void
4114catch_signals(void)
4115{
4116 struct sigaction action;
4117
4118 action.sa_flags = SA_SIGINFO | SA_RESETHAND;
4119 action.sa_sigaction = on_caught_signal;
4120 sigemptyset(&action.sa_mask);
4121 sigaction(SIGSEGV, &action, NULL);
4122 sigaction(SIGABRT, &action, NULL);
4123}
4124
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004125static void
4126handle_primary_client_destroyed(struct wl_listener *listener, void *data)
4127{
4128 struct wl_client *client = data;
4129
4130 weston_log("Primary client died. Closing...\n");
4131
4132 wl_display_terminate(wl_client_get_display(client));
4133}
4134
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004135int main(int argc, char *argv[])
4136{
Pekka Paalanen3ab72692012-06-08 17:27:28 +03004137 int ret = EXIT_SUCCESS;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004138 struct wl_display *display;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05004139 struct weston_compositor *ec;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02004140 struct wl_event_source *signals[4];
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05004141 struct wl_event_loop *loop;
Kristian Høgsberg8334bc12012-01-03 10:29:47 -05004142 struct weston_compositor
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004143 *(*backend_init)(struct wl_display *display,
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04004144 int *argc, char *argv[],
4145 struct weston_config *config);
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004146 int i, fd;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004147 char *backend = NULL;
Lubomir Rintelba44c6b2013-11-15 14:18:15 +01004148 char *option_backend = NULL;
Jason Ekstranda985da42013-08-22 17:28:03 -05004149 char *shell = NULL;
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004150 char *option_shell = NULL;
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04004151 char *modules, *option_modules = NULL;
Martin Minarik19e6f262012-06-07 13:08:46 +02004152 char *log = NULL;
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004153 char *server_socket = NULL, *end;
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004154 int32_t idle_time = 300;
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004155 int32_t help = 0;
Kristian Høgsbergeb00e2e2012-09-11 14:29:47 -04004156 char *socket_name = "wayland-0";
Scott Moreau12245142012-08-29 15:15:58 -06004157 int32_t version = 0;
Pekka Paalanen588bee12014-05-07 16:26:25 +03004158 int32_t noconfig = 0;
4159 struct weston_config *config = NULL;
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04004160 struct weston_config_section *section;
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004161 struct wl_client *primary_client;
4162 struct wl_listener primary_client_destroyed;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04004163
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004164 const struct weston_option core_options[] = {
Lubomir Rintelba44c6b2013-11-15 14:18:15 +01004165 { WESTON_OPTION_STRING, "backend", 'B', &option_backend },
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004166 { WESTON_OPTION_STRING, "shell", 0, &option_shell },
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004167 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
4168 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
Kristian Høgsberga6813d22012-09-12 12:21:01 -04004169 { WESTON_OPTION_STRING, "modules", 0, &option_modules },
Martin Minarik19e6f262012-06-07 13:08:46 +02004170 { WESTON_OPTION_STRING, "log", 0, &log },
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004171 { WESTON_OPTION_BOOLEAN, "help", 'h', &help },
Scott Moreau12245142012-08-29 15:15:58 -06004172 { WESTON_OPTION_BOOLEAN, "version", 0, &version },
Pekka Paalanen588bee12014-05-07 16:26:25 +03004173 { WESTON_OPTION_BOOLEAN, "no-config", 0, &noconfig },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04004174 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05004175
Kristian Høgsberg4172f662013-02-20 15:27:49 -05004176 parse_options(core_options, ARRAY_LENGTH(core_options), &argc, argv);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004177
Kristian Høgsberg572c2ff2012-07-30 15:41:14 -04004178 if (help)
4179 usage(EXIT_SUCCESS);
4180
Scott Moreau12245142012-08-29 15:15:58 -06004181 if (version) {
4182 printf(PACKAGE_STRING "\n");
4183 return EXIT_SUCCESS;
4184 }
4185
Rafal Mielniczuk6e0a7d82012-06-09 15:10:28 +02004186 weston_log_file_open(log);
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004187
Pekka Paalanenbce4c2b2012-06-11 14:04:21 +03004188 weston_log("%s\n"
4189 STAMP_SPACE "%s\n"
4190 STAMP_SPACE "Bug reports to: %s\n"
4191 STAMP_SPACE "Build: %s\n",
4192 PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT,
Kristian Høgsberg23cf9eb2012-06-11 12:06:30 -04004193 BUILD_ID);
Pekka Paalanen7f4d1a32012-06-11 14:06:03 +03004194 log_uname();
Kristian Høgsberga411c8b2012-06-08 16:16:52 -04004195
Martin Minarik37032f82012-06-18 20:15:18 +02004196 verify_xdg_runtime_dir();
4197
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004198 display = wl_display_create();
4199
Tiago Vignatti2116b892011-08-08 05:52:59 -07004200 loop = wl_display_get_event_loop(display);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02004201 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
4202 display);
4203 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
4204 display);
4205 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
4206 display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07004207
4208 wl_list_init(&child_process_list);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02004209 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
4210 NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05004211
Srivardhan Hebbarba2a36d2014-05-27 14:30:59 +05304212 if (!signals[0] || !signals[1] || !signals[2] || !signals[3]) {
4213 ret = EXIT_FAILURE;
4214 goto out_signals;
4215 }
4216
Pekka Paalanen588bee12014-05-07 16:26:25 +03004217 if (noconfig == 0)
4218 config = weston_config_parse("weston.ini");
Lubomir Rintelba44c6b2013-11-15 14:18:15 +01004219 if (config != NULL) {
4220 weston_log("Using config file '%s'\n",
4221 weston_config_get_full_path(config));
4222 } else {
4223 weston_log("Starting with no config file.\n");
4224 }
4225 section = weston_config_get_section(config, "core", NULL, NULL);
4226
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004227 if (option_backend)
4228 backend = strdup(option_backend);
4229 else
4230 weston_config_section_get_string(section, "backend", &backend,
4231 NULL);
4232
Kristian Høgsberg1c562182011-05-02 22:09:20 -04004233 if (!backend) {
Jason Ekstrandcf40a132014-04-02 19:53:56 -05004234 if (getenv("WAYLAND_DISPLAY") || getenv("WAYLAND_SOCKET"))
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004235 backend = strdup("wayland-backend.so");
Kristian Høgsberg1c562182011-05-02 22:09:20 -04004236 else if (getenv("DISPLAY"))
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004237 backend = strdup("x11-backend.so");
Kristian Høgsberg1c562182011-05-02 22:09:20 -04004238 else
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004239 backend = strdup(WESTON_NATIVE_BACKEND);
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04004240 }
4241
Ander Conselvan de Oliveira97f29522013-10-14 15:57:11 +03004242 backend_init = weston_load_module(backend, "backend_init");
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004243 free(backend);
Srivardhan Hebbarba2a36d2014-05-27 14:30:59 +05304244 if (!backend_init) {
4245 ret = EXIT_FAILURE;
4246 goto out_signals;
4247 }
Kristian Høgsberga9410222011-01-14 17:22:35 -05004248
Kristian Høgsberg14e438c2013-05-26 21:48:14 -04004249 ec = backend_init(display, &argc, argv, config);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05004250 if (ec == NULL) {
Pekka Paalanen33616392012-07-30 16:56:57 +03004251 weston_log("fatal: failed to create compositor\n");
Srivardhan Hebbarba2a36d2014-05-27 14:30:59 +05304252 ret = EXIT_FAILURE;
4253 goto out_signals;
Kristian Høgsberg841883b2008-12-05 11:19:56 -05004254 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04004255
Peter Maatmane5b42e42013-03-27 22:38:53 +01004256 catch_signals();
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04004257 segv_compositor = ec;
4258
Kristian Høgsbergbcacef12012-03-11 21:05:57 -04004259 ec->idle_time = idle_time;
Giulio Camuffocdb4d292013-11-14 23:42:53 +01004260 ec->default_pointer_grab = NULL;
Pekka Paalanen7296e792011-12-07 16:22:00 +02004261
Kristian Høgsbergeb00e2e2012-09-11 14:29:47 -04004262 setenv("WAYLAND_DISPLAY", socket_name, 1);
4263
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004264 if (option_shell)
4265 shell = strdup(option_shell);
4266 else
Jason Ekstranda985da42013-08-22 17:28:03 -05004267 weston_config_section_get_string(section, "shell", &shell,
4268 "desktop-shell.so");
Jason Ekstranda985da42013-08-22 17:28:03 -05004269
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004270 if (load_modules(ec, shell, &argc, argv) < 0) {
4271 free(shell);
Pekka Paalanen33616392012-07-30 16:56:57 +03004272 goto out;
U. Artie Eoff2e2384a2014-01-17 13:19:01 -08004273 }
4274 free(shell);
4275
4276 weston_config_section_get_string(section, "modules", &modules, "");
4277 if (load_modules(ec, modules, &argc, argv) < 0) {
4278 free(modules);
4279 goto out;
4280 }
4281 free(modules);
4282
Ossama Othmana50e6e42013-05-14 09:48:26 -07004283 if (load_modules(ec, option_modules, &argc, argv) < 0)
Pekka Paalanen33616392012-07-30 16:56:57 +03004284 goto out;
Tiago Vignattie4faa2a2012-04-16 17:31:44 +03004285
Kristian Høgsbergcb4685b2013-02-20 15:37:49 -05004286 for (i = 1; i < argc; i++)
4287 weston_log("fatal: unhandled option: %s\n", argv[i]);
4288 if (argc > 1) {
4289 ret = EXIT_FAILURE;
4290 goto out;
4291 }
4292
Pekka Paalanen7bb65102013-05-22 18:03:04 +03004293 weston_compositor_log_capabilities(ec);
4294
Jason Ekstrand923bfe62014-04-02 19:53:58 -05004295 server_socket = getenv("WAYLAND_SERVER_SOCKET");
4296 if (server_socket) {
4297 weston_log("Running with single client\n");
4298 fd = strtol(server_socket, &end, 0);
4299 if (*end != '\0')
4300 fd = -1;
4301 } else {
4302 fd = -1;
4303 }
4304
4305 if (fd != -1) {
4306 primary_client = wl_client_create(display, fd);
4307 if (!primary_client) {
4308 weston_log("fatal: failed to add client: %m\n");
4309 ret = EXIT_FAILURE;
4310 goto out;
4311 }
4312 primary_client_destroyed.notify =
4313 handle_primary_client_destroyed;
4314 wl_client_add_destroy_listener(primary_client,
4315 &primary_client_destroyed);
4316 } else {
4317 if (wl_display_add_socket(display, socket_name)) {
4318 weston_log("fatal: failed to add socket: %m\n");
4319 ret = EXIT_FAILURE;
4320 goto out;
4321 }
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004322 }
4323
Pekka Paalanenc0444e32012-01-05 16:28:21 +02004324 weston_compositor_wake(ec);
Kristian Høgsberg122912c2008-12-05 11:13:50 -05004325
Kristian Høgsberg7b884bc2012-07-31 14:32:01 -04004326 wl_display_run(display);
4327
4328 out:
Pekka Paalanen0135abe2012-01-03 10:01:20 +02004329 /* prevent further rendering while shutting down */
Philipp Brüschweiler57edf7f2013-03-29 13:01:56 +01004330 ec->state = WESTON_COMPOSITOR_OFFSCREEN;
Pekka Paalanen0135abe2012-01-03 10:01:20 +02004331
Kristian Høgsberg02e79dc2012-04-12 09:55:26 -04004332 wl_signal_emit(&ec->destroy_signal, ec);
Pekka Paalanen3c647232011-12-22 13:43:43 +02004333
Daniel Stone855028f2012-05-01 20:37:10 +01004334 weston_compositor_xkb_destroy(ec);
4335
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05004336 ec->destroy(ec);
Srivardhan Hebbarba2a36d2014-05-27 14:30:59 +05304337
4338out_signals:
4339 for (i = ARRAY_LENGTH(signals) - 1; i >= 0; i--)
4340 if (signals[i])
4341 wl_event_source_remove(signals[i]);
4342
Tiago Vignatti9e2be082011-12-19 00:04:46 +02004343 wl_display_destroy(display);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05004344
Martin Minarik19e6f262012-06-07 13:08:46 +02004345 weston_log_file_close();
4346
Pekka Paalanen3ab72692012-06-08 17:27:28 +03004347 return ret;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04004348}