blob: 4800971c1c8ddd1a66e1b11d35d38616e2566d70 [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
Kristian Høgsbergffd710e2008-12-02 15:15:01 -05004 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -04005 * Permission to use, copy, modify, distribute, and sell this software and
6 * its documentation for any purpose is hereby granted without fee, provided
7 * that the above copyright notice appear in all copies and that both that
8 * copyright notice and this permission notice appear in supporting
9 * documentation, and that the name of the copyright holders not be used in
10 * advertising or publicity pertaining to distribution of the software
11 * without specific, written prior permission. The copyright holders make
12 * no representations about the suitability of this software for any
13 * purpose. It is provided "as is" without express or implied warranty.
Kristian Høgsbergffd710e2008-12-02 15:15:01 -050014 *
Kristian Høgsberg96aa7da2011-09-15 15:43:14 -040015 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
16 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
17 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
18 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
19 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
20 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
21 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Kristian Høgsbergffd710e2008-12-02 15:15:01 -050022 */
23
Kristian Høgsberg06bc2642010-12-01 09:50:16 -050024#define _GNU_SOURCE
25
Kristian Høgsberga9410222011-01-14 17:22:35 -050026#include "config.h"
27
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>
Kristian Høgsberg27da5382011-06-21 17:32:25 -040036#include <sys/wait.h>
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020037#include <sys/types.h>
38#include <sys/socket.h>
Kristian Høgsberg16eb6752008-10-08 22:51:32 -040039#include <fcntl.h>
40#include <unistd.h>
Kristian Høgsberg54879822008-11-23 17:07:32 -050041#include <math.h>
Kristian Høgsbergfc783d42010-06-11 12:56:24 -040042#include <linux/input.h>
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -040043#include <dlfcn.h>
Kristian Høgsbergd34912c2011-05-02 10:36:04 -040044#include <getopt.h>
Kristian Høgsberg85449032011-05-02 12:11:07 -040045#include <signal.h>
Kristian Høgsberg890bc052008-12-30 14:31:33 -050046
Pekka Paalanen50719bc2011-11-22 14:18:50 +020047#include <wayland-server.h>
Kristian Høgsberg82863022010-06-04 21:52:02 -040048#include "compositor.h"
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -050049
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -050050static const char *option_socket_name = NULL;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -050051
Kristian Høgsberg27da5382011-06-21 17:32:25 -040052static struct wl_list child_process_list;
53
54static int
55sigchld_handler(int signal_number, void *data)
56{
57 struct wlsc_process *p;
58 int status;
59 pid_t pid;
60
61 pid = wait(&status);
62 wl_list_for_each(p, &child_process_list, link) {
63 if (p->pid == pid)
64 break;
65 }
66
67 if (&p->link == &child_process_list) {
68 fprintf(stderr, "unknown child process exited\n");
69 return 1;
70 }
71
72 wl_list_remove(&p->link);
73 p->cleanup(p, status);
74
75 return 1;
76}
77
78WL_EXPORT void
79wlsc_watch_process(struct wlsc_process *process)
80{
81 wl_list_insert(&child_process_list, &process->link);
82}
83
Benjamin Franzke06286262011-05-06 19:12:33 +020084static void
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020085child_client_exec(int sockfd, const char *path)
86{
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -050087 int clientfd;
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020088 char s[32];
Pekka Paalanenc47ddfd2011-12-08 10:44:56 +020089 sigset_t allsigs;
90
91 /* do not give our signal mask to the new process */
92 sigfillset(&allsigs);
93 sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +020094
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -050095 /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
96 * non-CLOEXEC fd to pass through exec. */
97 clientfd = dup(sockfd);
98 if (clientfd == -1) {
99 fprintf(stderr, "compositor: dup failed: %m\n");
100 return;
101 }
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200102
Kristian Høgsbergd42b0c92011-12-08 10:19:40 -0500103 snprintf(s, sizeof s, "%d", clientfd);
Pekka Paalanen409ef0a2011-12-02 15:30:21 +0200104 setenv("WAYLAND_SOCKET", s, 1);
105
106 if (execl(path, path, NULL) < 0)
107 fprintf(stderr, "compositor: executing '%s' failed: %m\n",
108 path);
109}
110
111WL_EXPORT struct wl_client *
112wlsc_client_launch(struct wlsc_compositor *compositor,
113 struct wlsc_process *proc,
114 const char *path,
115 wlsc_process_cleanup_func_t cleanup)
116{
117 int sv[2];
118 pid_t pid;
119 struct wl_client *client;
120
121 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) < 0) {
122 fprintf(stderr, "wlsc_client_launch: "
123 "socketpair failed while launching '%s': %m\n",
124 path);
125 return NULL;
126 }
127
128 pid = fork();
129 if (pid == -1) {
130 close(sv[0]);
131 close(sv[1]);
132 fprintf(stderr, "wlsc_client_launch: "
133 "fork failed while launching '%s': %m\n", path);
134 return NULL;
135 }
136
137 if (pid == 0) {
138 child_client_exec(sv[1], path);
139 exit(-1);
140 }
141
142 close(sv[1]);
143
144 client = wl_client_create(compositor->wl_display, sv[0]);
145 if (!client) {
146 close(sv[0]);
147 fprintf(stderr, "wlsc_client_launch: "
148 "wl_client_create failed while launching '%s'.\n",
149 path);
150 return NULL;
151 }
152
153 proc->pid = pid;
154 proc->cleanup = cleanup;
155 wlsc_watch_process(proc);
156
157 return client;
158}
159
160static void
Benjamin Franzke06286262011-05-06 19:12:33 +0200161surface_handle_buffer_destroy(struct wl_listener *listener,
162 struct wl_resource *resource, uint32_t time)
163{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400164 struct wlsc_surface *es = container_of(listener, struct wlsc_surface,
Benjamin Franzke06286262011-05-06 19:12:33 +0200165 buffer_destroy_listener);
Benjamin Franzke06286262011-05-06 19:12:33 +0200166
Kristian Høgsberg24596942011-10-24 17:51:02 -0400167 es->buffer = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200168}
169
170static void
171output_handle_scanout_buffer_destroy(struct wl_listener *listener,
172 struct wl_resource *resource,
173 uint32_t time)
174{
175 struct wlsc_output *output =
176 container_of(listener, struct wlsc_output,
177 scanout_buffer_destroy_listener);
Benjamin Franzke06286262011-05-06 19:12:33 +0200178
Kristian Høgsberg24596942011-10-24 17:51:02 -0400179 output->scanout_buffer = NULL;
Ander Conselvan de Oliveira9a38a0a2011-10-26 16:48:45 +0300180
181 if (!output->pending_scanout_buffer)
182 wlsc_compositor_schedule_repaint(output->compositor);
Benjamin Franzke06286262011-05-06 19:12:33 +0200183}
184
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300185static void
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400186output_handle_pending_scanout_buffer_destroy(struct wl_listener *listener,
187 struct wl_resource *resource,
188 uint32_t time)
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300189{
190 struct wlsc_output *output =
191 container_of(listener, struct wlsc_output,
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400192 pending_scanout_buffer_destroy_listener);
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300193
Kristian Høgsberg24596942011-10-24 17:51:02 -0400194 output->pending_scanout_buffer = NULL;
Ander Conselvan de Oliveira9a38a0a2011-10-26 16:48:45 +0300195
196 wlsc_compositor_schedule_repaint(output->compositor);
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300197}
198
199
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400200WL_EXPORT struct wlsc_surface *
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400201wlsc_surface_create(struct wlsc_compositor *compositor,
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400202 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500203{
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400204 struct wlsc_surface *surface;
205
Pekka Paalanen56cdea92011-11-23 16:14:12 +0200206 surface = calloc(1, sizeof *surface);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400207 if (surface == NULL)
208 return NULL;
209
Kristian Høgsbergf6b14712011-01-06 15:32:14 -0500210 wl_list_init(&surface->link);
Benjamin Franzkebab41fb2011-03-07 18:04:59 +0100211 wl_list_init(&surface->buffer_link);
Kristian Høgsbergc551bd22010-12-06 16:43:16 -0500212
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500213 glGenTextures(1, &surface->texture);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400214 glBindTexture(GL_TEXTURE_2D, surface->texture);
215 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
216 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400217
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400218 surface->surface.resource.client = NULL;
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400219
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500220 surface->compositor = compositor;
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400221 surface->visual = WLSC_NONE_VISUAL;
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200222 surface->image = EGL_NO_IMAGE_KHR;
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200223 surface->saved_texture = 0;
Kristian Høgsberg1db21f12010-08-16 16:08:12 -0400224 surface->x = x;
225 surface->y = y;
226 surface->width = width;
227 surface->height = height;
Kristian Høgsberg541e5552011-12-14 09:24:11 -0500228 surface->alpha = 255;
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400229
Kristian Høgsbergcbd06f92011-10-12 16:29:31 -0400230 surface->fullscreen_output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200231 surface->buffer = NULL;
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -0400232 surface->output = NULL;
Benjamin Franzke06286262011-05-06 19:12:33 +0200233
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400234 pixman_region32_init(&surface->damage);
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400235 pixman_region32_init(&surface->opaque);
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500236 wl_list_init(&surface->frame_callback_list);
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400237
Benjamin Franzke06286262011-05-06 19:12:33 +0200238 surface->buffer_destroy_listener.func = surface_handle_buffer_destroy;
Benjamin Franzke06286262011-05-06 19:12:33 +0200239
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400240 surface->transform = NULL;
Kristian Høgsberg1e4b86a2008-11-23 23:41:08 -0500241
Kristian Høgsberg77fb1672010-08-16 10:38:29 -0400242 return surface;
Kristian Høgsberg54879822008-11-23 17:07:32 -0500243}
244
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400245WL_EXPORT void
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500246wlsc_surface_damage_rectangle(struct wlsc_surface *surface,
247 int32_t x, int32_t y,
248 int32_t width, int32_t height)
249{
250 struct wlsc_compositor *compositor = surface->compositor;
251
Kristian Høgsberg20300ba2011-06-23 20:29:12 -0400252 pixman_region32_union_rect(&surface->damage,
253 &surface->damage,
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500254 surface->x + x, surface->y + y,
255 width, height);
256 wlsc_compositor_schedule_repaint(compositor);
257}
258
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400259WL_EXPORT void
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500260wlsc_surface_damage(struct wlsc_surface *surface)
261{
262 wlsc_surface_damage_rectangle(surface, 0, 0,
263 surface->width, surface->height);
264}
265
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400266WL_EXPORT void
267wlsc_surface_damage_below(struct wlsc_surface *surface)
268{
269 struct wlsc_surface *below;
270
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500271 if (surface->output == NULL)
Pekka Paalanend503a0b2011-11-15 13:34:53 +0200272 return;
273
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400274 if (surface->link.next == &surface->compositor->surface_list)
275 return;
276
277 below = container_of(surface->link.next, struct wlsc_surface, link);
278
279 pixman_region32_union_rect(&below->damage,
280 &below->damage,
281 surface->x, surface->y,
282 surface->width, surface->height);
283 wlsc_compositor_schedule_repaint(surface->compositor);
284}
285
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400286WL_EXPORT void
287wlsc_surface_configure(struct wlsc_surface *surface,
288 int x, int y, int width, int height)
289{
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400290 wlsc_surface_damage_below(surface);
291
292 surface->x = x;
293 surface->y = y;
294 surface->width = width;
295 surface->height = height;
296
297 wlsc_surface_assign_output(surface);
298 wlsc_surface_damage(surface);
299
300 pixman_region32_fini(&surface->opaque);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400301 if (surface->visual == WLSC_RGB_VISUAL)
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400302 pixman_region32_init_rect(&surface->opaque,
303 surface->x, surface->y,
304 surface->width, surface->height);
305 else
306 pixman_region32_init(&surface->opaque);
307}
308
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400309WL_EXPORT uint32_t
310wlsc_compositor_get_time(void)
Kristian Høgsberg7132a9a2010-12-06 21:41:10 -0500311{
312 struct timeval tv;
313
314 gettimeofday(&tv, NULL);
315
316 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
317}
318
Pekka Paalanenf0fc70d2011-11-15 13:34:54 +0200319WL_EXPORT void
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400320wlsc_compositor_repick(struct wlsc_compositor *compositor)
321{
322 struct wlsc_input_device *device;
323 struct wlsc_surface *surface;
324 int32_t sx, sy;
325 uint32_t time;
326
Kristian Høgsberg1ec0c312011-11-15 16:39:55 -0500327 if (!compositor->focus)
328 return;
329
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400330 time = wlsc_compositor_get_time();
331 wl_list_for_each(device, &compositor->input_device_list, link) {
Kristian Høgsberg32ff1f52011-10-12 00:36:54 -0400332 if (device->input_device.grab)
333 continue;
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400334 surface = pick_surface(&device->input_device, &sx, &sy);
335 wl_input_device_set_pointer_focus(&device->input_device,
336 &surface->surface,
337 time,
338 device->input_device.x,
339 device->input_device.y,
340 sx, sy);
341 }
342}
343
344static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400345destroy_surface(struct wl_resource *resource)
Kristian Høgsberg54879822008-11-23 17:07:32 -0500346{
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -0400347 struct wlsc_surface *surface =
Kristian Høgsbergb313b022010-12-01 17:07:41 -0500348 container_of(resource, struct wlsc_surface, surface.resource);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400349 struct wlsc_compositor *compositor = surface->compositor;
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400350
Kristian Høgsbergb8a98332011-06-23 21:00:04 -0400351 wlsc_surface_damage_below(surface);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500352
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400353 wl_list_remove(&surface->link);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400354 wlsc_compositor_repick(compositor);
355
Benjamin Franzke431da9a2011-04-20 11:02:58 +0200356 if (surface->saved_texture == 0)
357 glDeleteTextures(1, &surface->texture);
358 else
359 glDeleteTextures(1, &surface->saved_texture);
360
Benjamin Franzke06286262011-05-06 19:12:33 +0200361 if (surface->buffer)
362 wl_list_remove(&surface->buffer_destroy_listener.link);
Kristian Høgsberg3f8f39c2009-09-18 17:05:13 -0400363
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200364 if (surface->image != EGL_NO_IMAGE_KHR)
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400365 compositor->destroy_image(compositor->display,
366 surface->image);
Benjamin Franzke1178a3c2011-04-10 16:49:52 +0200367
Benjamin Franzkebab41fb2011-03-07 18:04:59 +0100368 wl_list_remove(&surface->buffer_link);
369
Pekka Paalanen402ae6d2012-01-03 10:23:24 +0200370 pixman_region32_fini(&surface->damage);
371 pixman_region32_fini(&surface->opaque);
372
Kristian Høgsberg4fa48732009-03-10 23:17:00 -0400373 free(surface);
Kristian Høgsberg54879822008-11-23 17:07:32 -0500374}
375
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100376static void
377wlsc_buffer_attach(struct wl_buffer *buffer, struct wl_surface *surface)
378{
379 struct wlsc_surface *es = (struct wlsc_surface *) surface;
380 struct wlsc_compositor *ec = es->compositor;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100381 struct wl_list *surfaces_attached_to;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100382
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100383 if (es->saved_texture != 0)
384 es->texture = es->saved_texture;
385
386 glBindTexture(GL_TEXTURE_2D, es->texture);
387
388 if (wl_buffer_is_shm(buffer)) {
389 /* Unbind any EGLImage texture that may be bound, so we don't
390 * overwrite it.*/
391 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
392 0, 0, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, NULL);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200393 es->pitch = wl_shm_buffer_get_stride(buffer) / 4;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100394 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200395 es->pitch, buffer->height, 0,
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100396 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
397 wl_shm_buffer_get_data(buffer));
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400398
399 switch (wl_shm_buffer_get_format(buffer)) {
400 case WL_SHM_FORMAT_ARGB32:
401 es->visual = WLSC_ARGB_VISUAL;
402 break;
403 case WL_SHM_FORMAT_PREMULTIPLIED_ARGB32:
404 es->visual = WLSC_PREMUL_ARGB_VISUAL;
405 break;
406 case WL_SHM_FORMAT_XRGB32:
407 es->visual = WLSC_RGB_VISUAL;
408 break;
409 }
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100410
411 surfaces_attached_to = buffer->user_data;
412
Kristian Høgsbergfac11d22011-05-02 13:35:17 -0400413 wl_list_remove(&es->buffer_link);
Benjamin Franzke315b3dc2011-03-08 11:32:57 +0100414 wl_list_insert(surfaces_attached_to, &es->buffer_link);
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100415 } else {
Benjamin Franzkefb4b5a22011-06-21 10:44:37 +0200416 if (es->image != EGL_NO_IMAGE_KHR)
417 ec->destroy_image(ec->display, es->image);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -0400418 es->image = ec->create_image(ec->display, NULL,
419 EGL_WAYLAND_BUFFER_WL,
420 buffer, NULL);
421
422 ec->image_target_texture_2d(GL_TEXTURE_2D, es->image);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400423
424 /* FIXME: we need to get the visual from the wl_buffer */
425 es->visual = WLSC_PREMUL_ARGB_VISUAL;
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200426 es->pitch = es->width;
Benjamin Franzkefaa0a9d2011-02-21 16:24:53 +0100427 }
428}
429
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400430static int
431texture_region(struct wlsc_surface *es, pixman_region32_t *region)
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500432{
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500433 struct wlsc_compositor *ec = es->compositor;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500434 GLfloat *v, inv_width, inv_height;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500435 pixman_box32_t *rectangles;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400436 unsigned int *p;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500437 int i, n;
438
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400439 rectangles = pixman_region32_rectangles(region, &n);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500440 v = wl_array_add(&ec->vertices, n * 16 * sizeof *v);
441 p = wl_array_add(&ec->indices, n * 6 * sizeof *p);
Benjamin Franzkefab5ec12011-04-25 19:44:47 +0200442 inv_width = 1.0 / es->pitch;
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500443 inv_height = 1.0 / es->height;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400444
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500445 for (i = 0; i < n; i++, v += 16, p += 6) {
446 v[ 0] = rectangles[i].x1;
447 v[ 1] = rectangles[i].y1;
448 v[ 2] = (GLfloat) (rectangles[i].x1 - es->x) * inv_width;
449 v[ 3] = (GLfloat) (rectangles[i].y1 - es->y) * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500450
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500451 v[ 4] = rectangles[i].x1;
452 v[ 5] = rectangles[i].y2;
453 v[ 6] = v[ 2];
454 v[ 7] = (GLfloat) (rectangles[i].y2 - es->y) * inv_height;
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500455
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500456 v[ 8] = rectangles[i].x2;
457 v[ 9] = rectangles[i].y1;
458 v[10] = (GLfloat) (rectangles[i].x2 - es->x) * inv_width;
459 v[11] = v[ 3];
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500460
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500461 v[12] = rectangles[i].x2;
462 v[13] = rectangles[i].y2;
463 v[14] = v[10];
464 v[15] = v[ 7];
465
466 p[0] = i * 4 + 0;
467 p[1] = i * 4 + 1;
468 p[2] = i * 4 + 2;
469 p[3] = i * 4 + 2;
470 p[4] = i * 4 + 1;
471 p[5] = i * 4 + 3;
472 }
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500473
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400474 return n;
475}
476
477static void
478transform_vertex(struct wlsc_surface *surface,
479 GLfloat x, GLfloat y, GLfloat u, GLfloat v, GLfloat *r)
480{
481 struct wlsc_vector t;
482
483 t.f[0] = x;
484 t.f[1] = y;
485 t.f[2] = 0.0;
486 t.f[3] = 1.0;
487
Kristian Høgsberg0bc0e242011-05-02 14:35:40 -0400488 wlsc_matrix_transform(&surface->transform->matrix, &t);
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400489
490 r[ 0] = t.f[0];
491 r[ 1] = t.f[1];
492 r[ 2] = u;
493 r[ 3] = v;
494}
495
496static int
497texture_transformed_surface(struct wlsc_surface *es)
498{
499 struct wlsc_compositor *ec = es->compositor;
500 GLfloat *v;
501 unsigned int *p;
502
503 v = wl_array_add(&ec->vertices, 16 * sizeof *v);
504 p = wl_array_add(&ec->indices, 6 * sizeof *p);
505
506 transform_vertex(es, es->x, es->y, 0.0, 0.0, &v[0]);
507 transform_vertex(es, es->x, es->y + es->height, 0.0, 1.0, &v[4]);
508 transform_vertex(es, es->x + es->width, es->y, 1.0, 0.0, &v[8]);
509 transform_vertex(es, es->x + es->width, es->y + es->height,
510 1.0, 1.0, &v[12]);
511
512 p[0] = 0;
513 p[1] = 1;
514 p[2] = 2;
515 p[3] = 2;
516 p[4] = 1;
517 p[5] = 3;
518
519 return 1;
520}
521
522static void
523wlsc_surface_draw(struct wlsc_surface *es,
524 struct wlsc_output *output, pixman_region32_t *clip)
525{
526 struct wlsc_compositor *ec = es->compositor;
527 GLfloat *v;
528 pixman_region32_t repaint;
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400529 GLint filter;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400530 int n;
531
532 pixman_region32_init_rect(&repaint,
533 es->x, es->y, es->width, es->height);
534 pixman_region32_intersect(&repaint, &repaint, clip);
535 if (!pixman_region32_not_empty(&repaint))
536 return;
537
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400538 switch (es->visual) {
539 case WLSC_ARGB_VISUAL:
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400540 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
541 glEnable(GL_BLEND);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400542 break;
543 case WLSC_PREMUL_ARGB_VISUAL:
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400544 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
545 glEnable(GL_BLEND);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400546 break;
547 case WLSC_RGB_VISUAL:
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400548 glDisable(GL_BLEND);
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400549 break;
550 default:
551 fprintf(stderr, "bogus visual\n");
552 break;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400553 }
554
Kristian Høgsberg541e5552011-12-14 09:24:11 -0500555 if (es->alpha != ec->current_alpha) {
556 glUniform1f(ec->texture_shader.alpha_uniform,
557 es->alpha / 255.0);
558 ec->current_alpha = es->alpha;
559 }
560
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400561 if (es->transform == NULL) {
562 filter = GL_NEAREST;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400563 n = texture_region(es, &repaint);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400564 } else {
565 filter = GL_LINEAR;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400566 n = texture_transformed_surface(es);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400567 }
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400568
Kristian Høgsbergaa5b5be2008-11-21 21:31:54 -0500569 glBindTexture(GL_TEXTURE_2D, es->texture);
Kristian Høgsberg40caded2011-06-20 19:48:16 -0400570 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
571 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
572
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500573 v = ec->vertices.data;
574 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[0]);
575 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof *v, &v[2]);
Kristian Høgsberg27803c62010-06-06 22:23:21 -0400576 glEnableVertexAttribArray(0);
577 glEnableVertexAttribArray(1);
Kristian Høgsberg525e4c02011-02-14 10:39:54 -0500578 glDrawElements(GL_TRIANGLES, n * 6, GL_UNSIGNED_INT, ec->indices.data);
579
580 ec->vertices.size = 0;
581 ec->indices.size = 0;
582 pixman_region32_fini(&repaint);
Kristian Høgsberg4c9f2c92008-11-21 19:25:44 -0500583}
584
585static void
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400586wlsc_surface_raise(struct wlsc_surface *surface)
587{
588 struct wlsc_compositor *compositor = surface->compositor;
589
590 wl_list_remove(&surface->link);
Kristian Høgsberg747638b2010-07-12 17:06:06 -0400591 wl_list_insert(&compositor->surface_list, &surface->link);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400592 wlsc_compositor_repick(compositor);
Kristian Høgsbergcd0d10b2011-06-24 08:28:07 -0400593 wlsc_surface_damage(surface);
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400594}
595
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400596WL_EXPORT void
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400597wlsc_compositor_damage_all(struct wlsc_compositor *compositor)
598{
599 struct wlsc_output *output;
600
601 wl_list_for_each(output, &compositor->output_list, link)
602 wlsc_output_damage(output);
603}
604
Benjamin Franzke06286262011-05-06 19:12:33 +0200605static inline void
606wlsc_buffer_post_release(struct wl_buffer *buffer)
607{
Kristian Høgsberg24596942011-10-24 17:51:02 -0400608 if (--buffer->busy_count > 0)
Benjamin Franzke06286262011-05-06 19:12:33 +0200609 return;
Benjamin Franzke06286262011-05-06 19:12:33 +0200610
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400611 assert(buffer->resource.client != NULL);
Kristian Høgsbergeccef6a2011-11-17 16:46:19 -0500612 wl_resource_queue_event(&buffer->resource, WL_BUFFER_RELEASE);
Benjamin Franzke06286262011-05-06 19:12:33 +0200613}
614
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400615WL_EXPORT void
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400616wlsc_output_damage(struct wlsc_output *output)
617{
618 struct wlsc_compositor *compositor = output->compositor;
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500619 struct wlsc_surface *es;
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400620
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500621 if (wl_list_empty(&compositor->surface_list))
622 return;
623
624 es = container_of(compositor->surface_list.next,
625 struct wlsc_surface, link);
626 pixman_region32_union(&es->damage, &es->damage, &output->region);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400627 wlsc_compositor_schedule_repaint(compositor);
628}
629
Kristian Høgsberg01f941b2009-05-27 17:47:15 -0400630static void
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400631fade_frame(struct wlsc_animation *animation,
632 struct wlsc_output *output, uint32_t msecs)
633{
634 struct wlsc_compositor *compositor =
635 container_of(animation,
636 struct wlsc_compositor, fade.animation);
637
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400638 wlsc_spring_update(&compositor->fade.spring, msecs);
639 if (wlsc_spring_done(&compositor->fade.spring)) {
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400640 compositor->fade.spring.current =
641 compositor->fade.spring.target;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400642 wl_list_remove(&animation->link);
643 wl_list_init(&animation->link);
Pekka Paalanen2e097ee2011-12-02 10:39:49 +0200644
645 if (compositor->fade.spring.current > 0.999) {
646 compositor->state = WLSC_COMPOSITOR_SLEEPING;
647 compositor->shell->lock(compositor->shell);
648 }
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400649 }
650
651 wlsc_output_damage(output);
652}
653
654static void
655fade_output(struct wlsc_output *output,
656 GLfloat tint, pixman_region32_t *region)
657{
658 struct wlsc_compositor *compositor = output->compositor;
659 struct wlsc_surface surface;
660 GLfloat color[4] = { 0.0, 0.0, 0.0, tint };
661
662 surface.compositor = compositor;
663 surface.x = output->x;
664 surface.y = output->y;
Tiago Vignatti2cc8b872011-08-19 15:10:40 +0300665 surface.pitch = output->current->width;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400666 surface.width = output->current->width;
667 surface.height = output->current->height;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400668 surface.texture = GL_NONE;
Kristian Høgsberg2e94d112011-05-02 13:47:51 -0400669 surface.transform = NULL;
Pekka Paalanen3429a722011-12-20 16:38:25 +0200670 surface.alpha = compositor->current_alpha;
Kristian Høgsbergc352ab02011-04-23 15:34:50 -0400671
672 if (tint <= 1.0)
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400673 surface.visual = WLSC_PREMUL_ARGB_VISUAL;
Kristian Høgsbergc352ab02011-04-23 15:34:50 -0400674 else
Kristian Høgsbergf389cac2011-08-31 16:21:38 -0400675 surface.visual = WLSC_RGB_VISUAL;
Kristian Høgsbergc352ab02011-04-23 15:34:50 -0400676
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400677 glUseProgram(compositor->solid_shader.program);
678 glUniformMatrix4fv(compositor->solid_shader.proj_uniform,
679 1, GL_FALSE, output->matrix.d);
680 glUniform4fv(compositor->solid_shader.color_uniform, 1, color);
681 wlsc_surface_draw(&surface, output, region);
682}
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200683
684static void
685wlsc_output_set_cursor(struct wlsc_output *output,
686 struct wl_input_device *dev, int force_sw)
687{
688 struct wlsc_compositor *ec = output->compositor;
689 struct wlsc_input_device *device = (struct wlsc_input_device *) dev;
690 pixman_region32_t cursor_region;
691 int use_hardware_cursor = 1, prior_was_hardware;
692
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -0500693 if (device->sprite == NULL)
694 return;
695
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200696 pixman_region32_init_rect(&cursor_region,
697 device->sprite->x, device->sprite->y,
698 device->sprite->width,
699 device->sprite->height);
700
701 pixman_region32_intersect(&cursor_region, &cursor_region, &output->region);
702
703 if (!pixman_region32_not_empty(&cursor_region)) {
Ander Conselvan de Oliveira02924bc2011-10-24 16:30:15 +0300704 output->set_hardware_cursor(output, NULL);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200705 goto out;
706 }
707
708 prior_was_hardware = wl_list_empty(&device->sprite->link);
709 if (force_sw || output->set_hardware_cursor(output, device) < 0) {
Matt Roper11568a72011-08-29 15:59:37 -0700710 if (prior_was_hardware) {
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200711 wlsc_surface_damage(device->sprite);
Matt Roper11568a72011-08-29 15:59:37 -0700712 output->set_hardware_cursor(output, NULL);
713 }
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200714 use_hardware_cursor = 0;
715 } else if (!prior_was_hardware) {
716 wlsc_surface_damage_below(device->sprite);
717 }
718
719 /* Remove always to be on top. */
720 wl_list_remove(&device->sprite->link);
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500721 if (!use_hardware_cursor && ec->focus) {
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200722 wl_list_insert(&ec->surface_list, &device->sprite->link);
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500723 device->sprite->output = output;
724 } else {
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200725 wl_list_init(&device->sprite->link);
Kristian Høgsberg2584cb52011-11-22 19:47:57 -0500726 device->sprite->output = NULL;
727 }
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200728
729out:
730 pixman_region32_fini(&cursor_region);
731}
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400732
Ander Conselvan de Oliveira3b199662011-10-18 17:02:06 +0300733static int
734setup_scanout_surface(struct wlsc_output *output, struct wlsc_surface *es)
735{
736 if (es->visual != WLSC_RGB_VISUAL ||
737 output->prepare_scanout_surface(output, es) != 0)
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400738 return -1;
Ander Conselvan de Oliveira3b199662011-10-18 17:02:06 +0300739
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400740 /* assert output->pending_scanout_buffer == NULL */
741 output->pending_scanout_buffer = es->buffer;
742 output->pending_scanout_buffer->busy_count++;
Ander Conselvan de Oliveira3b199662011-10-18 17:02:06 +0300743
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400744 wl_list_insert(output->pending_scanout_buffer->resource.destroy_listener_list.prev,
745 &output->pending_scanout_buffer_destroy_listener.link);
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +0300746
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400747 return 0;
Ander Conselvan de Oliveira3b199662011-10-18 17:02:06 +0300748}
749
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400750static void
Kristian Høgsbergfc783d42010-06-11 12:56:24 -0400751wlsc_output_repaint(struct wlsc_output *output)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400752{
Kristian Høgsberg1a208d52009-02-10 14:20:26 -0500753 struct wlsc_compositor *ec = output->compositor;
Kristian Høgsberg8e438622009-01-26 23:07:00 -0500754 struct wlsc_surface *es;
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400755 pixman_region32_t opaque, new_damage, total_damage, repaint;
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500756
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +0100757 output->prepare_render(output);
758
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400759 glViewport(0, 0, output->current->width, output->current->height);
Kristian Høgsbergfdec2362001-01-01 22:23:51 -0500760
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -0400761 glUseProgram(ec->texture_shader.program);
762 glUniformMatrix4fv(ec->texture_shader.proj_uniform,
763 1, GL_FALSE, output->matrix.d);
764 glUniform1i(ec->texture_shader.tex_uniform, 0);
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -0500765
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200766 wlsc_output_set_cursor(output, ec->input_device,
Kristian Høgsberg4ebf3a02011-08-29 16:47:09 -0400767 ec->fade.spring.current >= 0.001);
Benjamin Franzkea8bdeae2011-06-28 22:56:43 +0200768
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500769 pixman_region32_init(&new_damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400770 pixman_region32_init(&opaque);
Pekka Paalanencc9102e2012-01-02 15:42:44 +0200771
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400772 wl_list_for_each(es, &ec->surface_list, link) {
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400773 pixman_region32_subtract(&es->damage, &es->damage, &opaque);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400774 pixman_region32_union(&new_damage, &new_damage, &es->damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400775 pixman_region32_union(&opaque, &opaque, &es->opaque);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400776 }
777
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400778 pixman_region32_init(&total_damage);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500779 pixman_region32_union(&total_damage, &new_damage,
Kristian Høgsberg8b72f602011-06-23 20:46:34 -0400780 &output->previous_damage);
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400781 pixman_region32_intersect(&output->previous_damage,
782 &new_damage, &output->region);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500783
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400784 pixman_region32_fini(&opaque);
Kristian Høgsberg53df1d82011-06-23 21:11:19 -0400785 pixman_region32_fini(&new_damage);
786
Kristian Høgsberg0ce24572011-01-28 15:18:33 -0500787 es = container_of(ec->surface_list.next, struct wlsc_surface, link);
Benjamin Franzke66aa2352011-04-20 17:06:13 +0200788
Kristian Høgsbergd8264042011-11-11 11:48:12 -0500789 if (setup_scanout_surface(output, es) == 0)
790 /* We're drawing nothing, just let the damage accumulate */
Kristian Høgsberg8244b442011-06-23 15:44:14 -0400791 return;
Kristian Høgsberg4d07a1c2011-05-06 14:03:12 -0400792
793 if (es->fullscreen_output == output) {
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -0400794 if (es->width < output->current->width ||
795 es->height < output->current->height)
Benjamin Franzke66aa2352011-04-20 17:06:13 +0200796 glClear(GL_COLOR_BUFFER_BIT);
797 wlsc_surface_draw(es, output, &total_damage);
Kristian Høgsberg0ce24572011-01-28 15:18:33 -0500798 } else {
Kristian Høgsbergaee7f842011-06-23 21:25:20 -0400799 wl_list_for_each(es, &ec->surface_list, link) {
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400800 pixman_region32_copy(&es->damage, &total_damage);
801 pixman_region32_subtract(&total_damage, &total_damage, &es->opaque);
Kristian Høgsbergaee7f842011-06-23 21:25:20 -0400802 }
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -0500803
Kristian Høgsbergaee7f842011-06-23 21:25:20 -0400804 wl_list_for_each_reverse(es, &ec->surface_list, link) {
Kristian Høgsberg7341e9b2011-07-01 22:12:11 -0400805 pixman_region32_init(&repaint);
806 pixman_region32_intersect(&repaint, &output->region,
807 &es->damage);
808 wlsc_surface_draw(es, output, &repaint);
809 pixman_region32_subtract(&es->damage,
810 &es->damage, &output->region);
Pekka Paalanencc9102e2012-01-02 15:42:44 +0200811 pixman_region32_fini(&repaint);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -0500812 }
Kristian Høgsberg0ce24572011-01-28 15:18:33 -0500813 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400814
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400815 if (ec->fade.spring.current > 0.001)
816 fade_output(output, ec->fade.spring.current, &total_damage);
Pekka Paalanencc9102e2012-01-02 15:42:44 +0200817
818 pixman_region32_fini(&total_damage);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500819}
820
Kristian Høgsberg33418202011-08-16 23:01:28 -0400821struct wlsc_frame_callback {
822 struct wl_resource resource;
Kristian Høgsberg33418202011-08-16 23:01:28 -0400823 struct wl_list link;
824};
825
Kristian Høgsbergef044142011-06-21 15:02:12 -0400826static void
827repaint(void *data, int msecs)
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500828{
Kristian Høgsbergef044142011-06-21 15:02:12 -0400829 struct wlsc_output *output = data;
830 struct wlsc_compositor *compositor = output->compositor;
Kristian Høgsbergef044142011-06-21 15:02:12 -0400831 struct wlsc_animation *animation, *next;
Kristian Høgsberg33418202011-08-16 23:01:28 -0400832 struct wlsc_frame_callback *cb, *cnext;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500833
Kristian Høgsbergef044142011-06-21 15:02:12 -0400834 wlsc_output_repaint(output);
835 output->repaint_needed = 0;
836 output->repaint_scheduled = 1;
837 output->present(output);
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100838
Kristian Høgsberg33418202011-08-16 23:01:28 -0400839 wl_list_for_each_safe(cb, cnext, &output->frame_callback_list, link) {
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400840 wl_resource_post_event(&cb->resource, WL_CALLBACK_DONE, msecs);
841 wl_resource_destroy(&cb->resource, 0);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -0500842 }
843
Kristian Høgsbergef044142011-06-21 15:02:12 -0400844 wl_list_for_each_safe(animation, next,
845 &compositor->animation_list, link)
846 animation->frame(animation, output, msecs);
847}
Kristian Høgsbergb1868472011-04-22 12:27:57 -0400848
Kristian Høgsbergef044142011-06-21 15:02:12 -0400849static void
850idle_repaint(void *data)
851{
852 repaint(data, wlsc_compositor_get_time());
853}
854
855WL_EXPORT void
856wlsc_output_finish_frame(struct wlsc_output *output, int msecs)
857{
Kristian Høgsberg191454e2011-10-20 17:51:45 -0400858 if (output->scanout_buffer) {
859 wlsc_buffer_post_release(output->scanout_buffer);
860 wl_list_remove(&output->scanout_buffer_destroy_listener.link);
861 output->scanout_buffer = NULL;
862 }
863
864 if (output->pending_scanout_buffer) {
865 output->scanout_buffer = output->pending_scanout_buffer;
866 wl_list_remove(&output->pending_scanout_buffer_destroy_listener.link);
867 wl_list_insert(output->scanout_buffer->resource.destroy_listener_list.prev,
868 &output->scanout_buffer_destroy_listener.link);
869 output->pending_scanout_buffer = NULL;
870 }
871
Kristian Høgsbergef044142011-06-21 15:02:12 -0400872 if (output->repaint_needed)
873 repaint(output, msecs);
Ander Conselvan de Oliveira22e22a52011-10-24 16:30:14 +0300874 else
875 output->repaint_scheduled = 0;
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400876}
877
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400878WL_EXPORT void
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -0400879wlsc_compositor_schedule_repaint(struct wlsc_compositor *compositor)
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400880{
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100881 struct wlsc_output *output;
Kristian Høgsbergef044142011-06-21 15:02:12 -0400882 struct wl_event_loop *loop;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100883
Kristian Høgsberge10a5d92011-04-22 14:01:18 -0400884 if (compositor->state == WLSC_COMPOSITOR_SLEEPING)
885 return;
886
Kristian Høgsbergef044142011-06-21 15:02:12 -0400887 loop = wl_display_get_event_loop(compositor->wl_display);
888 wl_list_for_each(output, &compositor->output_list, link) {
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100889 output->repaint_needed = 1;
Kristian Høgsbergef044142011-06-21 15:02:12 -0400890 if (output->repaint_scheduled)
891 continue;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100892
Kristian Høgsbergef044142011-06-21 15:02:12 -0400893 wl_event_loop_add_idle(loop, idle_repaint, output);
894 output->repaint_scheduled = 1;
895 }
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -0400896}
Kristian Høgsberg5c8c3282009-02-09 15:17:46 -0500897
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400898WL_EXPORT void
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400899wlsc_compositor_fade(struct wlsc_compositor *compositor, float tint)
900{
901 int done;
902
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400903 done = wlsc_spring_done(&compositor->fade.spring);
904 compositor->fade.spring.target = tint;
905 if (wlsc_spring_done(&compositor->fade.spring))
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400906 return;
907
908 if (done)
Kristian Høgsberg269c7822011-05-02 14:38:18 -0400909 compositor->fade.spring.timestamp =
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400910 wlsc_compositor_get_time();
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -0400911
912 wlsc_compositor_damage_all(compositor);
913 if (wl_list_empty(&compositor->fade.animation.link))
914 wl_list_insert(compositor->animation_list.prev,
915 &compositor->fade.animation.link);
916}
917
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500918static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400919surface_destroy(struct wl_client *client, struct wl_resource *resource)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400920{
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400921 wl_resource_destroy(resource, wlsc_compositor_get_time());
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400922}
923
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -0400924WL_EXPORT void
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100925wlsc_surface_assign_output(struct wlsc_surface *es)
926{
927 struct wlsc_compositor *ec = es->compositor;
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500928 struct wlsc_output *output, *new_output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -0700929 pixman_region32_t region;
930 uint32_t max, area;
931 pixman_box32_t *e;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100932
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500933 new_output = NULL;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -0700934 max = 0;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100935 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg4f0df042011-07-21 11:30:22 -0700936 pixman_region32_init_rect(&region,
937 es->x, es->y, es->width, es->height);
938 pixman_region32_intersect(&region, &region, &output->region);
939
940 e = pixman_region32_extents(&region);
941 area = (e->x2 - e->x1) * (e->y2 - e->y1);
942
943 if (area >= max) {
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500944 new_output = output;
Kristian Høgsberg4f0df042011-07-21 11:30:22 -0700945 max = area;
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100946 }
947 }
Kristian Høgsberg496433b2011-11-15 13:50:21 -0500948
949 es->output = new_output;
950 if (!wl_list_empty(&es->frame_callback_list)) {
951 wl_list_insert_list(new_output->frame_callback_list.prev,
952 &es->frame_callback_list);
953 wl_list_init(&es->frame_callback_list);
954 }
Benjamin Franzkeec4d3422011-03-14 12:07:26 +0100955}
956
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500957static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500958surface_attach(struct wl_client *client,
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -0400959 struct wl_resource *resource,
960 struct wl_resource *buffer_resource, int32_t x, int32_t y)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400961{
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400962 struct wlsc_surface *es = resource->data;
Kristian Høgsberg32e24cc2011-11-09 12:07:35 -0500963 struct wlsc_shell *shell = es->compositor->shell;
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -0400964 struct wl_buffer *buffer = buffer_resource->data;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -0400965
Kristian Høgsberg24596942011-10-24 17:51:02 -0400966 if (es->buffer) {
967 wlsc_buffer_post_release(es->buffer);
968 wl_list_remove(&es->buffer_destroy_listener.link);
969 }
Benjamin Franzke06286262011-05-06 19:12:33 +0200970
Kristian Høgsberg24596942011-10-24 17:51:02 -0400971 buffer->busy_count++;
Benjamin Franzke06286262011-05-06 19:12:33 +0200972 es->buffer = buffer;
Benjamin Franzke06286262011-05-06 19:12:33 +0200973 wl_list_insert(es->buffer->resource.destroy_listener_list.prev,
974 &es->buffer_destroy_listener.link);
975
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400976 if (es->visual == WLSC_NONE_VISUAL) {
Kristian Høgsberg32e24cc2011-11-09 12:07:35 -0500977 shell->map(shell, es, buffer->width, buffer->height);
978 } else if (x != 0 || y != 0 ||
979 es->width != buffer->width ||
980 es->height != buffer->height) {
981 shell->configure(shell, es, es->x + x, es->y + y,
982 buffer->width, buffer->height);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -0400983 }
Kristian Høgsberga691aee2011-06-23 21:43:50 -0400984
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400985 wlsc_buffer_attach(buffer, &es->surface);
Kristian Høgsbergf9212892008-10-11 18:40:23 -0400986}
987
Kristian Høgsberg5503bf82008-11-06 10:38:17 -0500988static void
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500989surface_damage(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400990 struct wl_resource *resource,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -0500991 int32_t x, int32_t y, int32_t width, int32_t height)
Kristian Høgsberg7f77bd82008-11-07 08:39:37 -0500992{
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400993 struct wlsc_surface *es = resource->data;
Kristian Høgsberg9d69f8e2010-09-03 14:46:38 -0400994
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -0500995 wlsc_surface_damage_rectangle(es, x, y, width, height);
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -0500996}
997
Kristian Høgsberg33418202011-08-16 23:01:28 -0400998static void
Kristian Høgsberg904055a2011-08-18 17:55:30 -0400999destroy_frame_callback(struct wl_resource *resource)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001000{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001001 struct wlsc_frame_callback *cb = resource->data;
1002
1003 wl_list_remove(&cb->link);
Pekka Paalanen8c196452011-11-15 11:45:42 +02001004 free(cb);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001005}
1006
1007static void
1008surface_frame(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001009 struct wl_resource *resource, uint32_t callback)
Kristian Høgsberg33418202011-08-16 23:01:28 -04001010{
1011 struct wlsc_frame_callback *cb;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001012 struct wlsc_surface *es = resource->data;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001013
1014 cb = malloc(sizeof *cb);
1015 if (cb == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001016 wl_resource_post_no_memory(resource);
Kristian Høgsberg33418202011-08-16 23:01:28 -04001017 return;
1018 }
1019
1020 cb->resource.object.interface = &wl_callback_interface;
1021 cb->resource.object.id = callback;
1022 cb->resource.destroy = destroy_frame_callback;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001023 cb->resource.client = client;
1024 cb->resource.data = cb;
Kristian Høgsberg33418202011-08-16 23:01:28 -04001025
1026 wl_client_add_resource(client, &cb->resource);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001027
1028 if (es->output) {
1029 wl_list_insert(es->output->frame_callback_list.prev,
1030 &cb->link);
1031 } else {
Kristian Høgsberg496433b2011-11-15 13:50:21 -05001032 wl_list_insert(es->frame_callback_list.prev, &cb->link);
Kristian Høgsberg6f7179c2011-08-29 16:09:32 -04001033 }
Kristian Høgsberg33418202011-08-16 23:01:28 -04001034}
1035
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001036const static struct wl_surface_interface surface_interface = {
1037 surface_destroy,
1038 surface_attach,
Kristian Høgsberg33418202011-08-16 23:01:28 -04001039 surface_damage,
1040 surface_frame
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001041};
1042
1043static void
1044compositor_create_surface(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001045 struct wl_resource *resource, uint32_t id)
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001046{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001047 struct wlsc_compositor *ec = resource->data;
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -04001048 struct wlsc_surface *surface;
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001049
Kristian Høgsbergc5d6be92011-01-14 16:22:37 -05001050 surface = wlsc_surface_create(ec, 0, 0, 0, 0);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001051 if (surface == NULL) {
Kristian Høgsberg9ebcf942011-09-01 09:54:57 -04001052 wl_resource_post_no_memory(resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001053 return;
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001054 }
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001055
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001056 surface->surface.resource.destroy = destroy_surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001057
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001058 surface->surface.resource.object.id = id;
1059 surface->surface.resource.object.interface = &wl_surface_interface;
1060 surface->surface.resource.object.implementation =
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001061 (void (**)(void)) &surface_interface;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001062 surface->surface.resource.data = surface;
Kristian Høgsbergf66d0f42010-09-02 20:27:16 -04001063
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001064 wl_client_add_resource(client, &surface->surface.resource);
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001065}
1066
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001067const static struct wl_compositor_interface compositor_interface = {
1068 compositor_create_surface,
Kristian Høgsbergd2412e22008-12-15 20:35:24 -05001069};
1070
Kristian Høgsberg7b6907f2009-02-14 17:47:55 -05001071static void
1072wlsc_surface_transform(struct wlsc_surface *surface,
1073 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
1074{
Kristian Høgsberg2e94d112011-05-02 13:47:51 -04001075 *sx = x - surface->x;
1076 *sy = y - surface->y;
Kristian Høgsberg7b6907f2009-02-14 17:47:55 -05001077}
1078
Kristian Høgsberg773d13b2011-12-21 15:15:08 -05001079static struct wlsc_surface *
1080wlsc_compositor_pick_surface(struct wlsc_compositor *compositor,
1081 int32_t x, int32_t y, int32_t *sx, int32_t *sy)
1082{
1083 struct wlsc_surface *surface;
1084
1085 wl_list_for_each(surface, &compositor->surface_list, link) {
1086 if (surface->surface.resource.client == NULL)
1087 continue;
1088 wlsc_surface_transform(surface, x, y, sx, sy);
1089 if (0 <= *sx && *sx < surface->width &&
1090 0 <= *sy && *sy < surface->height)
1091 return surface;
1092 }
1093
1094 return NULL;
1095}
1096
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001097WL_EXPORT struct wlsc_surface *
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001098pick_surface(struct wl_input_device *device, int32_t *sx, int32_t *sy)
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001099{
Kristian Høgsberga8873122011-11-23 10:39:34 -05001100 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001101
Kristian Høgsberg773d13b2011-12-21 15:15:08 -05001102 return wlsc_compositor_pick_surface(wd->compositor,
1103 device->x, device->y, sx, sy);
Kristian Høgsberg201a9042008-12-10 00:40:50 -05001104}
1105
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001106
1107static void
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001108implicit_grab_motion(struct wl_grab *grab,
1109 uint32_t time, int32_t x, int32_t y)
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001110{
1111 struct wlsc_input_device *device =
1112 (struct wlsc_input_device *) grab->input_device;
1113 struct wlsc_surface *es =
1114 (struct wlsc_surface *) device->input_device.pointer_focus;
1115 int32_t sx, sy;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001116 struct wl_resource *resource;
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001117
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001118 resource = grab->input_device->pointer_focus_resource;
1119 if (resource) {
1120 wlsc_surface_transform(es, x, y, &sx, &sy);
1121 wl_resource_post_event(resource, WL_INPUT_DEVICE_MOTION,
1122 time, x, y, sx, sy);
1123 }
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001124}
1125
1126static void
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001127implicit_grab_button(struct wl_grab *grab,
1128 uint32_t time, int32_t button, int32_t state)
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001129{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001130 struct wl_resource *resource;
1131
1132 resource = grab->input_device->pointer_focus_resource;
1133 if (resource)
1134 wl_resource_post_event(resource, WL_INPUT_DEVICE_BUTTON,
1135 time, button, state);
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001136}
1137
1138static void
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001139implicit_grab_end(struct wl_grab *grab, uint32_t time)
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001140{
1141}
1142
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001143static const struct wl_grab_interface implicit_grab_interface = {
1144 implicit_grab_motion,
1145 implicit_grab_button,
1146 implicit_grab_end
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001147};
1148
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001149WL_EXPORT void
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001150wlsc_compositor_wake(struct wlsc_compositor *compositor)
1151{
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001152 compositor->state = WLSC_COMPOSITOR_ACTIVE;
Pekka Paalanenebc598e2011-11-15 13:34:51 +02001153 wlsc_compositor_fade(compositor, 0.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001154
1155 wl_event_source_timer_update(compositor->idle_source,
Pekka Paalanen7296e792011-12-07 16:22:00 +02001156 compositor->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001157}
1158
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001159WL_EXPORT void
1160wlsc_compositor_activity(struct wlsc_compositor *compositor)
1161{
Pekka Paalanenbce2d3f2011-12-02 13:07:27 +02001162 if (compositor->state == WLSC_COMPOSITOR_ACTIVE) {
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001163 wlsc_compositor_wake(compositor);
1164 } else {
1165 compositor->shell->unlock(compositor->shell);
1166 }
1167}
1168
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001169static void
1170wlsc_compositor_idle_inhibit(struct wlsc_compositor *compositor)
1171{
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001172 wlsc_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001173 compositor->idle_inhibit++;
1174}
1175
1176static void
1177wlsc_compositor_idle_release(struct wlsc_compositor *compositor)
1178{
1179 compositor->idle_inhibit--;
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001180 wlsc_compositor_activity(compositor);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001181}
1182
1183static int
1184idle_handler(void *data)
1185{
1186 struct wlsc_compositor *compositor = data;
1187
1188 if (compositor->idle_inhibit)
1189 return 1;
1190
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001191 wlsc_compositor_fade(compositor, 1.0);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001192
1193 return 1;
1194}
1195
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001196WL_EXPORT void
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001197notify_motion(struct wl_input_device *device, uint32_t time, int x, int y)
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001198{
Kristian Høgsberg8e438622009-01-26 23:07:00 -05001199 struct wlsc_surface *es;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001200 struct wlsc_output *output;
Kristian Høgsberg6d65d5f2010-12-07 13:30:18 -05001201 const struct wl_grab_interface *interface;
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001202 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001203 struct wlsc_compositor *ec = wd->compositor;
Kristian Høgsbergfc9c28a2010-12-07 13:04:43 -05001204 int32_t sx, sy;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001205 int x_valid = 0, y_valid = 0;
1206 int min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN;
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001207
Kristian Høgsbergaf867cc2011-11-15 13:34:49 +02001208 wlsc_compositor_activity(ec);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001209
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001210 wl_list_for_each(output, &ec->output_list, link) {
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001211 if (output->x <= x && x <= output->x + output->current->width)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001212 x_valid = 1;
1213
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001214 if (output->y <= y && y <= output->y + output->current->height)
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001215 y_valid = 1;
1216
1217 /* FIXME: calculate this only on output addition/deletion */
1218 if (output->x < min_x)
1219 min_x = output->x;
1220 if (output->y < min_y)
1221 min_y = output->y;
1222
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001223 if (output->x + output->current->width > max_x)
1224 max_x = output->x + output->current->width;
1225 if (output->y + output->current->height > max_y)
1226 max_y = output->y + output->current->height;
Benjamin Franzkeeefc36c2011-03-11 16:39:20 +01001227 }
1228
1229 if (!x_valid) {
1230 if (x < min_x)
1231 x = min_x;
1232 else if (x >= max_x)
1233 x = max_x;
1234 }
1235 if (!y_valid) {
1236 if (y < min_y)
1237 y = min_y;
1238 else if (y >= max_y)
1239 y = max_y;
1240 }
Ray Strode90e701d2008-12-18 23:05:43 -05001241
Kristian Høgsberge3ef3e52008-12-21 19:30:01 -05001242 device->x = x;
1243 device->y = y;
Kristian Høgsbergdb6c2f32009-02-22 21:51:24 -05001244
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001245 if (device->grab) {
1246 interface = device->grab->interface;
1247 interface->motion(device->grab, time, x, y);
1248 } else {
Kristian Høgsberg83fc0612010-08-04 22:44:55 -04001249 es = pick_surface(device, &sx, &sy);
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001250 wl_input_device_set_pointer_focus(device,
Kristian Høgsbergb313b022010-12-01 17:07:41 -05001251 &es->surface,
Kristian Høgsberg26437072010-12-01 10:17:47 -05001252 time, x, y, sx, sy);
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001253 if (device->pointer_focus_resource)
1254 wl_resource_post_event(device->pointer_focus_resource,
1255 WL_INPUT_DEVICE_MOTION,
1256 time, x, y, sx, sy);
Kristian Høgsberg83fc0612010-08-04 22:44:55 -04001257 }
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001258
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001259 if (wd->sprite) {
1260 wlsc_surface_damage_below(wd->sprite);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001261
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001262 wd->sprite->x = device->x - wd->hotspot_x;
1263 wd->sprite->y = device->y - wd->hotspot_y;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001264
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001265 wlsc_surface_damage(wd->sprite);
1266 }
Kristian Høgsberg715a0812008-12-10 10:42:04 -05001267}
1268
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04001269WL_EXPORT void
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001270wlsc_surface_activate(struct wlsc_surface *surface,
1271 struct wlsc_input_device *device, uint32_t time)
1272{
1273 wlsc_surface_raise(surface);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001274 wl_input_device_set_keyboard_focus(&device->input_device,
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001275 &surface->surface, time);
1276 wlsc_data_device_set_keyboard_focus(device);
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001277}
1278
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001279WL_EXPORT void
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001280notify_button(struct wl_input_device *device,
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001281 uint32_t time, int32_t button, int32_t state)
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001282{
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001283 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001284 struct wlsc_compositor *compositor = wd->compositor;
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001285 struct wlsc_surface *surface =
1286 (struct wlsc_surface *) device->pointer_focus;
Kristian Høgsberg4eaa8302011-09-06 13:41:47 -04001287 int32_t sx, sy;
Kristian Høgsbergea081152010-12-07 08:59:51 -05001288
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001289 if (state)
1290 wlsc_compositor_idle_inhibit(compositor);
1291 else
1292 wlsc_compositor_idle_release(compositor);
1293
Kristian Høgsberg2bd5b632011-12-19 14:59:57 -05001294 wlsc_compositor_run_binding(compositor, wd, time, 0, button, state);
Kristian Høgsbergb3fc7572010-12-08 11:07:57 -05001295
Kristian Høgsberg5a5f0072011-12-19 14:54:11 -05001296 if (state && surface && device->grab == NULL) {
1297 wl_input_device_start_grab(device,
1298 &device->implicit_grab,
1299 button, time);
1300 }
1301
Kristian Høgsbergdd4046a2011-01-21 17:00:09 -05001302 if (device->grab)
1303 device->grab->interface->button(device->grab, time,
1304 button, state);
Kristian Høgsbergdff2e3c2010-12-07 09:02:09 -05001305
Kristian Høgsberg4eaa8302011-09-06 13:41:47 -04001306 if (!state && device->grab && device->grab_button == button) {
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001307 wl_input_device_end_grab(device, time);
Kristian Høgsberg4eaa8302011-09-06 13:41:47 -04001308 surface = pick_surface(device, &sx, &sy);
1309 wl_input_device_set_pointer_focus(device, &surface->surface,
1310 time, device->x, device->y,
1311 sx, sy);
1312 }
Kristian Høgsbergeac149a2008-12-10 00:24:18 -05001313}
1314
Kristian Høgsbergc9824dd2011-02-06 16:54:59 -05001315static void
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001316update_modifier_state(struct wlsc_input_device *device,
1317 uint32_t key, uint32_t state)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001318{
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001319 uint32_t modifier;
Kristian Høgsbergab909ae2001-01-01 22:24:24 -05001320
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001321 switch (key) {
1322 case KEY_LEFTCTRL:
1323 case KEY_RIGHTCTRL:
1324 modifier = MODIFIER_CTRL;
1325 break;
1326
1327 case KEY_LEFTALT:
1328 case KEY_RIGHTALT:
1329 modifier = MODIFIER_ALT;
1330 break;
1331
Kristian Høgsberg5b75f1b2010-08-04 23:21:41 -04001332 case KEY_LEFTMETA:
1333 case KEY_RIGHTMETA:
1334 modifier = MODIFIER_SUPER;
1335 break;
1336
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001337 default:
1338 modifier = 0;
1339 break;
1340 }
1341
1342 if (state)
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001343 device->modifier_state |= modifier;
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001344 else
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001345 device->modifier_state &= ~modifier;
1346}
Kristian Høgsberg2cbedd12009-09-18 17:29:49 -04001347
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001348WL_EXPORT void
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001349notify_key(struct wl_input_device *device,
1350 uint32_t time, uint32_t key, uint32_t state)
1351{
1352 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001353 struct wlsc_compositor *compositor = wd->compositor;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001354 uint32_t *k, *end;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001355
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001356 if (state)
1357 wlsc_compositor_idle_inhibit(compositor);
1358 else
1359 wlsc_compositor_idle_release(compositor);
1360
Kristian Høgsberg2bd5b632011-12-19 14:59:57 -05001361 wlsc_compositor_run_binding(compositor, wd, time, key, 0, state);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001362
1363 update_modifier_state(wd, key, state);
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001364 end = device->keys.data + device->keys.size;
1365 for (k = device->keys.data; k < end; k++) {
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001366 if (*k == key)
1367 *k = *--end;
1368 }
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001369 device->keys.size = (void *) end - device->keys.data;
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001370 if (state) {
Kristian Høgsberg9c3e8d72010-12-08 09:48:52 -05001371 k = wl_array_add(&device->keys, sizeof *k);
Kristian Høgsberg3c38fa02009-02-23 22:30:29 -05001372 *k = key;
1373 }
Ray Strodee96dcb82008-12-20 02:00:49 -05001374
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001375 if (device->keyboard_focus_resource)
1376 wl_resource_post_event(device->keyboard_focus_resource,
1377 WL_INPUT_DEVICE_KEY, time, key, state);
Kristian Høgsberg808fd412010-07-20 17:06:19 -04001378}
1379
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001380WL_EXPORT void
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001381notify_pointer_focus(struct wl_input_device *device,
1382 uint32_t time, struct wlsc_output *output,
1383 int32_t x, int32_t y)
1384{
1385 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001386 struct wlsc_compositor *compositor = wd->compositor;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001387 struct wlsc_surface *es;
1388 int32_t sx, sy;
1389
1390 if (output) {
1391 device->x = x;
1392 device->y = y;
1393 es = pick_surface(device, &sx, &sy);
1394 wl_input_device_set_pointer_focus(device,
1395 &es->surface,
1396 time, x, y, sx, sy);
1397
1398 compositor->focus = 1;
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001399 } else {
1400 wl_input_device_set_pointer_focus(device, NULL,
1401 time, 0, 0, 0, 0);
1402 compositor->focus = 0;
1403 }
Kristian Høgsberg93331ff2011-01-26 20:35:07 -05001404}
1405
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001406WL_EXPORT void
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001407notify_keyboard_focus(struct wl_input_device *device,
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001408 uint32_t time, struct wlsc_output *output,
1409 struct wl_array *keys)
1410{
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001411 struct wlsc_input_device *wd =
1412 (struct wlsc_input_device *) device;
Kristian Høgsberga8873122011-11-23 10:39:34 -05001413 struct wlsc_compositor *compositor = wd->compositor;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001414 struct wlsc_surface *es;
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001415 uint32_t *k, *end;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001416
1417 if (!wl_list_empty(&compositor->surface_list))
1418 es = container_of(compositor->surface_list.next,
1419 struct wlsc_surface, link);
1420 else
1421 es = NULL;
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001422
1423 if (output) {
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001424 wl_array_copy(&wd->input_device.keys, keys);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001425 wd->modifier_state = 0;
1426 end = device->keys.data + device->keys.size;
1427 for (k = device->keys.data; k < end; k++) {
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001428 wlsc_compositor_idle_inhibit(compositor);
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001429 update_modifier_state(wd, *k, 1);
1430 }
1431
Kristian Høgsbergf59da392011-09-06 13:44:56 -04001432 if (es && es->surface.resource.client)
Benjamin Franzkeb7c00a42011-06-23 23:30:30 +02001433 wl_input_device_set_keyboard_focus(&wd->input_device,
1434 &es->surface, time);
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001435 } else {
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04001436 end = device->keys.data + device->keys.size;
1437 for (k = device->keys.data; k < end; k++)
1438 wlsc_compositor_idle_release(compositor);
1439
Kristian Høgsbergf512d072011-04-12 17:16:00 -04001440 wd->modifier_state = 0;
Kristian Høgsbergf992b2f2011-01-28 15:53:07 -05001441 wl_input_device_set_keyboard_focus(&wd->input_device,
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001442 NULL, time);
1443 }
1444}
1445
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001446/* TODO: share this function with wayland-server.c */
1447static struct wl_resource *
1448find_resource_for_surface(struct wl_list *list, struct wl_surface *surface)
1449{
1450 struct wl_resource *r;
1451
1452 if (!surface)
1453 return NULL;
1454
1455 wl_list_for_each(r, list, link) {
1456 if (r->client == surface->resource.client)
1457 return r;
1458 }
1459
1460 return NULL;
1461}
1462
1463static void
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001464lose_touch_focus_resource(struct wl_listener *listener,
1465 struct wl_resource *resource, uint32_t time)
1466{
1467 struct wlsc_input_device *device =
1468 container_of(listener, struct wlsc_input_device,
1469 touch_focus_resource_listener);
1470
1471 device->touch_focus_resource = NULL;
1472}
1473
1474static void
1475lose_touch_focus(struct wl_listener *listener,
1476 struct wl_resource *resource, uint32_t time)
1477{
1478 struct wlsc_input_device *device =
1479 container_of(listener, struct wlsc_input_device,
1480 touch_focus_listener);
1481
1482 device->touch_focus = NULL;
1483}
1484
1485static void
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001486touch_set_focus(struct wlsc_input_device *device,
1487 struct wl_surface *surface, uint32_t time)
1488{
1489 struct wl_input_device *input_device = &device->input_device;
1490 struct wl_resource *resource;
1491
1492 if (device->touch_focus == surface)
1493 return;
1494
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001495 if (surface) {
1496 resource =
1497 find_resource_for_surface(&input_device->resource_list,
1498 surface);
1499 if (!resource) {
1500 fprintf(stderr, "couldn't find resource\n");
1501 return;
1502 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001503
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001504 device->touch_focus_resource_listener.func =
1505 lose_touch_focus_resource;
1506 wl_list_insert(resource->destroy_listener_list.prev,
1507 &device->touch_focus_resource_listener.link);
1508 device->touch_focus_listener.func = lose_touch_focus;
1509 wl_list_insert(surface->resource.destroy_listener_list.prev,
1510 &device->touch_focus_listener.link);
1511
1512 device->touch_focus = surface;
1513 device->touch_focus_resource = resource;
1514 } else {
1515 if (device->touch_focus)
1516 wl_list_remove(&device->touch_focus_listener.link);
1517 if (device->touch_focus_resource)
1518 wl_list_remove(&device->touch_focus_resource_listener.link);
1519 device->touch_focus = NULL;
1520 device->touch_focus_resource = NULL;
1521 }
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001522}
1523
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001524/**
1525 * notify_touch - emulates button touches and notifies surfaces accordingly.
1526 *
1527 * It assumes always the correct cycle sequence until it gets here: touch_down
1528 * → touch_update → ... → touch_update → touch_end. The driver is responsible
1529 * for sending along such order.
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001530 *
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001531 */
1532WL_EXPORT void
1533notify_touch(struct wl_input_device *device, uint32_t time, int touch_id,
1534 int x, int y, int touch_type)
1535{
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001536 struct wlsc_input_device *wd = (struct wlsc_input_device *) device;
1537 struct wlsc_compositor *ec = wd->compositor;
1538 struct wlsc_surface *es;
1539 int32_t sx, sy;
1540
1541 switch (touch_type) {
1542 case WL_INPUT_DEVICE_TOUCH_DOWN:
1543 wlsc_compositor_idle_inhibit(ec);
1544
1545 wd->num_tp++;
1546
1547 /* the first finger down picks the surface, and all further go
1548 * to that surface for the remainder of the touch session i.e.
1549 * until all touch points are up again. */
1550 if (wd->num_tp == 1) {
1551 es = wlsc_compositor_pick_surface(ec, x, y, &sx, &sy);
1552 touch_set_focus(wd, &es->surface, time);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001553 } else if (wd->touch_focus) {
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001554 es = (struct wlsc_surface *) wd->touch_focus;
1555 wlsc_surface_transform(es, x, y, &sx, &sy);
1556 }
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001557
1558 if (wd->touch_focus_resource && wd->touch_focus)
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001559 wl_resource_post_event(wd->touch_focus_resource,
1560 touch_type, time,
1561 wd->touch_focus,
1562 touch_id, sx, sy);
1563 break;
1564 case WL_INPUT_DEVICE_TOUCH_MOTION:
1565 es = (struct wlsc_surface *) wd->touch_focus;
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001566 if (!es)
1567 break;
1568
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001569 wlsc_surface_transform(es, x, y, &sx, &sy);
1570 if (wd->touch_focus_resource)
1571 wl_resource_post_event(wd->touch_focus_resource,
Kristian Høgsberg3543ff42011-12-21 17:25:54 -05001572 touch_type, time,
1573 touch_id, sx, sy);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001574 break;
1575 case WL_INPUT_DEVICE_TOUCH_UP:
1576 wlsc_compositor_idle_release(ec);
1577 wd->num_tp--;
1578
Kristian Høgsberg3543ff42011-12-21 17:25:54 -05001579 if (wd->touch_focus_resource)
1580 wl_resource_post_event(wd->touch_focus_resource,
1581 touch_type, time, touch_id);
Kristian Høgsberg03cb5cf2011-12-22 14:43:09 -05001582 if (wd->num_tp == 0)
1583 touch_set_focus(wd, NULL, time);
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001584 break;
1585 }
Tiago Vignatti22c6bce2011-12-21 19:34:09 +02001586}
Kristian Høgsberg3ba48582011-01-27 11:57:19 -05001587
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04001588static void
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001589input_device_attach(struct wl_client *client,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001590 struct wl_resource *resource,
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001591 uint32_t time,
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001592 struct wl_resource *buffer_resource, int32_t x, int32_t y)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001593{
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001594 struct wlsc_input_device *device = resource->data;
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001595 struct wlsc_compositor *compositor = device->compositor;
Kristian Høgsberg57295eb2011-08-29 16:02:57 -04001596 struct wl_buffer *buffer;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001597
1598 if (time < device->input_device.pointer_focus_time)
1599 return;
1600 if (device->input_device.pointer_focus == NULL)
1601 return;
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001602 if (device->input_device.pointer_focus->resource.client != client)
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001603 return;
1604
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001605 if (device->sprite)
1606 wlsc_surface_damage_below(device->sprite);
1607
1608 if (!buffer_resource) {
1609 destroy_surface(&device->sprite->surface.resource);
1610 device->sprite = NULL;
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001611 return;
1612 }
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001613
1614 if (!device->sprite) {
1615 device->sprite =
1616 wlsc_surface_create(compositor,
1617 device->input_device.x,
1618 device->input_device.y, 32, 32);
1619 wl_list_init(&device->sprite->link);
1620 }
1621
1622 buffer = buffer_resource->data;
1623 wlsc_buffer_attach(buffer, &device->sprite->surface);
1624
1625 device->hotspot_x = x;
1626 device->hotspot_y = y;
1627 device->sprite->width = buffer->width;
1628 device->sprite->height = buffer->height;
1629 device->sprite->x = device->input_device.x - device->hotspot_x;
1630 device->sprite->y = device->input_device.y - device->hotspot_y;
1631
1632 wlsc_surface_damage(device->sprite);
Kristian Høgsbergab1862d2010-12-09 11:29:40 -05001633}
1634
1635const static struct wl_input_device_interface input_device_interface = {
1636 input_device_attach,
1637};
1638
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001639static void unbind_input_device(struct wl_resource *resource)
1640{
1641 wl_list_remove(&resource->link);
1642 free(resource);
1643}
1644
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001645static void
1646bind_input_device(struct wl_client *client,
1647 void *data, uint32_t version, uint32_t id)
1648{
Kristian Høgsberg8e6d7122011-08-29 16:04:39 -04001649 struct wl_input_device *device = data;
1650 struct wl_resource *resource;
1651
1652 resource = wl_client_add_object(client, &wl_input_device_interface,
1653 &input_device_interface, id, data);
1654 wl_list_insert(&device->resource_list, &resource->link);
Kristian Høgsbergd2baf1f2011-10-11 22:20:37 -04001655 resource->destroy = unbind_input_device;
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001656}
1657
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001658WL_EXPORT void
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001659wlsc_input_device_init(struct wlsc_input_device *device,
1660 struct wlsc_compositor *ec)
Kristian Høgsbergcddc0ad2008-11-24 00:31:49 -05001661{
Kristian Høgsberga8873122011-11-23 10:39:34 -05001662 wl_input_device_init(&device->input_device);
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001663 wl_list_init(&device->drag_resource_list);
Kristian Høgsberg02ef1c12010-12-06 21:35:19 -05001664
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001665 wl_display_add_global(ec->wl_display, &wl_input_device_interface,
1666 device, bind_input_device);
Kristian Høgsberg5fcd0aa2010-08-09 14:43:33 -04001667
Kristian Høgsbergcd9ac1d2011-12-15 09:14:34 -05001668 device->sprite = NULL;
Kristian Høgsberg8244b442011-06-23 15:44:14 -04001669
Kristian Høgsberga8873122011-11-23 10:39:34 -05001670 device->compositor = ec;
Kristian Høgsberg77fb1672010-08-16 10:38:29 -04001671 device->hotspot_x = 16;
1672 device->hotspot_y = 16;
Kristian Høgsberga8ec8632011-04-12 17:22:49 -04001673 device->modifier_state = 0;
Tiago Vignatti1f221ff2011-12-21 19:34:10 +02001674 device->num_tp = 0;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001675
Kristian Høgsberg9c4eecb2011-09-06 18:13:14 -04001676 device->input_device.implicit_grab.interface = &implicit_grab_interface;
Kristian Høgsberg8321e692010-12-07 17:06:15 -05001677
Kristian Høgsbergc492b482008-12-12 12:00:02 -05001678 wl_list_insert(ec->input_device_list.prev, &device->link);
Kristian Høgsberg1db21f12010-08-16 16:08:12 -04001679
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04001680 device->selection_data_source = NULL;
Kristian Høgsberg5ee1a602008-12-11 23:18:45 -05001681}
1682
Pekka Paalanen07753fb2012-01-02 15:31:01 +02001683WL_EXPORT void
1684wlsc_input_device_fini(struct wlsc_input_device *device)
1685{
1686 wl_list_remove(&device->link);
1687 /* The global object is destroyed at wl_display_destroy() time. */
1688
1689 if (device->sprite)
1690 destroy_surface(&device->sprite->surface.resource);
1691
1692 wl_input_device_fini(&device->input_device);
1693}
1694
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001695static void
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001696bind_output(struct wl_client *client,
1697 void *data, uint32_t version, uint32_t id)
Kristian Høgsbergbf9541f2008-11-25 12:10:09 -05001698{
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001699 struct wlsc_output *output = data;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001700 struct wlsc_mode *mode;
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001701 struct wl_resource *resource;
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001702
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001703 resource = wl_client_add_object(client,
1704 &wl_output_interface, NULL, id, data);
1705
1706 wl_resource_post_event(resource,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001707 WL_OUTPUT_GEOMETRY,
1708 output->x,
1709 output->y,
1710 output->mm_width,
1711 output->mm_height,
1712 output->subpixel,
1713 output->make, output->model);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001714
1715 wl_list_for_each (mode, &output->mode_list, link) {
Kristian Høgsbergfd07fb72011-08-29 15:03:09 -04001716 wl_resource_post_event(resource,
Kristian Høgsberg904055a2011-08-18 17:55:30 -04001717 WL_OUTPUT_MODE,
1718 mode->flags,
1719 mode->width,
1720 mode->height,
1721 mode->refresh);
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001722 }
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05001723}
1724
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001725static const char vertex_shader[] =
1726 "uniform mat4 proj;\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05001727 "attribute vec2 position;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001728 "attribute vec2 texcoord;\n"
1729 "varying vec2 v_texcoord;\n"
1730 "void main()\n"
1731 "{\n"
Kristian Høgsbergfa4e2a72011-02-13 13:44:55 -05001732 " gl_Position = proj * vec4(position, 0.0, 1.0);\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001733 " v_texcoord = texcoord;\n"
1734 "}\n";
1735
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001736static const char texture_fragment_shader[] =
Kristian Høgsbergdfce71d2010-12-07 20:19:10 -05001737 "precision mediump float;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001738 "varying vec2 v_texcoord;\n"
1739 "uniform sampler2D tex;\n"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05001740 "uniform float alpha;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001741 "void main()\n"
1742 "{\n"
1743 " gl_FragColor = texture2D(tex, v_texcoord)\n;"
Kristian Høgsberg541e5552011-12-14 09:24:11 -05001744 " gl_FragColor = alpha * gl_FragColor;\n"
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001745 "}\n";
1746
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001747static const char solid_fragment_shader[] =
1748 "precision mediump float;\n"
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001749 "uniform vec4 color;\n"
1750 "void main()\n"
1751 "{\n"
1752 " gl_FragColor = color\n;"
1753 "}\n";
1754
Kristian Høgsberga9468212010-06-14 21:03:11 -04001755static int
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001756compile_shader(GLenum type, const char *source)
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001757{
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001758 GLuint s;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001759 char msg[512];
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001760 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001761
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001762 s = glCreateShader(type);
1763 glShaderSource(s, 1, &source, NULL);
1764 glCompileShader(s);
1765 glGetShaderiv(s, GL_COMPILE_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001766 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001767 glGetShaderInfoLog(s, sizeof msg, NULL, msg);
1768 fprintf(stderr, "shader info: %s\n", msg);
1769 return GL_NONE;
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001770 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001771
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001772 return s;
1773}
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001774
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001775static int
1776wlsc_shader_init(struct wlsc_shader *shader,
1777 const char *vertex_source, const char *fragment_source)
1778{
1779 char msg[512];
1780 GLint status;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001781
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001782 shader->vertex_shader =
1783 compile_shader(GL_VERTEX_SHADER, vertex_source);
1784 shader->fragment_shader =
1785 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
1786
1787 shader->program = glCreateProgram();
1788 glAttachShader(shader->program, shader->vertex_shader);
1789 glAttachShader(shader->program, shader->fragment_shader);
1790 glBindAttribLocation(shader->program, 0, "position");
1791 glBindAttribLocation(shader->program, 1, "texcoord");
1792
1793 glLinkProgram(shader->program);
1794 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001795 if (!status) {
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001796 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001797 fprintf(stderr, "link info: %s\n", msg);
1798 return -1;
1799 }
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001800
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04001801 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1802 shader->tex_uniform = glGetUniformLocation(shader->program, "tex");
Kristian Høgsberg541e5552011-12-14 09:24:11 -05001803 shader->alpha_uniform = glGetUniformLocation(shader->program, "alpha");
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001804
Kristian Høgsberg67a21bd2010-06-25 18:58:24 -04001805 return 0;
Kristian Høgsberg27803c62010-06-06 22:23:21 -04001806}
1807
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04001808static int
1809init_solid_shader(struct wlsc_shader *shader,
1810 GLuint vertex_shader, const char *fragment_source)
1811{
1812 GLint status;
1813 char msg[512];
1814
1815 shader->vertex_shader = vertex_shader;
1816 shader->fragment_shader =
1817 compile_shader(GL_FRAGMENT_SHADER, fragment_source);
1818
1819 shader->program = glCreateProgram();
1820 glAttachShader(shader->program, shader->vertex_shader);
1821 glAttachShader(shader->program, shader->fragment_shader);
1822 glBindAttribLocation(shader->program, 0, "position");
1823 glBindAttribLocation(shader->program, 1, "texcoord");
1824
1825 glLinkProgram(shader->program);
1826 glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
1827 if (!status) {
1828 glGetProgramInfoLog(shader->program, sizeof msg, NULL, msg);
1829 fprintf(stderr, "link info: %s\n", msg);
1830 return -1;
1831 }
1832
1833 shader->proj_uniform = glGetUniformLocation(shader->program, "proj");
1834 shader->color_uniform = glGetUniformLocation(shader->program, "color");
1835
1836 return 0;
1837}
1838
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001839WL_EXPORT void
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001840wlsc_output_destroy(struct wlsc_output *output)
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001841{
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04001842 pixman_region32_fini(&output->region);
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04001843 pixman_region32_fini(&output->previous_damage);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001844}
1845
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001846WL_EXPORT void
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001847wlsc_output_move(struct wlsc_output *output, int x, int y)
1848{
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01001849 int flip;
1850
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001851 output->x = x;
1852 output->y = y;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001853
Kristian Høgsberg8b72f602011-06-23 20:46:34 -04001854 pixman_region32_init(&output->previous_damage);
Kristian Høgsberge75cb7f2011-06-21 15:27:41 -04001855 pixman_region32_init_rect(&output->region, x, y,
1856 output->current->width,
1857 output->current->height);
Kristian Høgsberg31bd6c72011-02-13 13:00:51 -05001858
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001859 wlsc_matrix_init(&output->matrix);
1860 wlsc_matrix_translate(&output->matrix,
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001861 -output->x - output->current->width / 2.0,
1862 -output->y - output->current->height / 2.0, 0);
Benjamin Franzke1b765ff2011-02-18 16:51:37 +01001863
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001864 flip = (output->flags & WL_OUTPUT_FLIPPED) ? -1 : 1;
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001865 wlsc_matrix_scale(&output->matrix,
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001866 2.0 / output->current->width,
1867 flip * 2.0 / output->current->height, 1);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001868
Kristian Høgsbergd8264042011-11-11 11:48:12 -05001869 wlsc_output_damage(output);
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001870}
1871
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001872WL_EXPORT void
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001873wlsc_output_init(struct wlsc_output *output, struct wlsc_compositor *c,
1874 int x, int y, int width, int height, uint32_t flags)
1875{
1876 output->compositor = c;
1877 output->x = x;
1878 output->y = y;
Kristian Høgsberg8f0ce052011-06-21 11:16:58 -04001879 output->mm_width = width;
1880 output->mm_height = height;
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001881
Benjamin Franzke9c26ff32011-03-15 15:08:41 +01001882 output->flags = flags;
1883 wlsc_output_move(output, x, y);
1884
Benjamin Franzke06286262011-05-06 19:12:33 +02001885 output->scanout_buffer_destroy_listener.func =
1886 output_handle_scanout_buffer_destroy;
Kristian Høgsberg191454e2011-10-20 17:51:45 -04001887 output->pending_scanout_buffer_destroy_listener.func =
1888 output_handle_pending_scanout_buffer_destroy;
Ander Conselvan de Oliveiraf1621d22011-10-18 17:02:07 +03001889
Kristian Høgsberg33418202011-08-16 23:01:28 -04001890 wl_list_init(&output->frame_callback_list);
Benjamin Franzke06286262011-05-06 19:12:33 +02001891
Kristian Høgsberg97d44aa2011-08-26 17:21:20 -04001892 wl_display_add_global(c->wl_display,
1893 &wl_output_interface, output, bind_output);
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001894}
1895
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001896static void
1897shm_buffer_created(struct wl_buffer *buffer)
1898{
1899 struct wl_list *surfaces_attached_to;
1900
1901 surfaces_attached_to = malloc(sizeof *surfaces_attached_to);
1902 if (!surfaces_attached_to) {
1903 buffer->user_data = NULL;
1904 return;
1905 }
1906
1907 wl_list_init(surfaces_attached_to);
1908
1909 buffer->user_data = surfaces_attached_to;
1910}
1911
1912static void
1913shm_buffer_damaged(struct wl_buffer *buffer,
1914 int32_t x, int32_t y, int32_t width, int32_t height)
1915{
1916 struct wl_list *surfaces_attached_to = buffer->user_data;
1917 struct wlsc_surface *es;
Benjamin Franzkefab5ec12011-04-25 19:44:47 +02001918 GLsizei tex_width = wl_shm_buffer_get_stride(buffer) / 4;
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001919
1920 wl_list_for_each(es, surfaces_attached_to, buffer_link) {
1921 glBindTexture(GL_TEXTURE_2D, es->texture);
1922 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT,
Benjamin Franzkefab5ec12011-04-25 19:44:47 +02001923 tex_width, buffer->height, 0,
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001924 GL_BGRA_EXT, GL_UNSIGNED_BYTE,
1925 wl_shm_buffer_get_data(buffer));
1926 /* Hmm, should use glTexSubImage2D() here but GLES2 doesn't
1927 * support any unpack attributes except GL_UNPACK_ALIGNMENT. */
1928 }
1929}
1930
1931static void
1932shm_buffer_destroyed(struct wl_buffer *buffer)
1933{
1934 struct wl_list *surfaces_attached_to = buffer->user_data;
1935 struct wlsc_surface *es, *next;
1936
1937 wl_list_for_each_safe(es, next, surfaces_attached_to, buffer_link) {
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001938 wl_list_remove(&es->buffer_link);
Kristian Høgsbergfac11d22011-05-02 13:35:17 -04001939 wl_list_init(&es->buffer_link);
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001940 }
1941
1942 free(surfaces_attached_to);
1943}
1944
1945const static struct wl_shm_callbacks shm_callbacks = {
1946 shm_buffer_created,
1947 shm_buffer_damaged,
1948 shm_buffer_destroyed
1949};
1950
Kristian Høgsberga8873122011-11-23 10:39:34 -05001951static void
1952compositor_bind(struct wl_client *client,
1953 void *data, uint32_t version, uint32_t id)
1954{
1955 struct wlsc_compositor *compositor = data;
1956
1957 wl_client_add_object(client, &wl_compositor_interface,
1958 &compositor_interface, id, compositor);
1959}
1960
Kristian Høgsberg1c562182011-05-02 22:09:20 -04001961WL_EXPORT int
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04001962wlsc_compositor_init(struct wlsc_compositor *ec, struct wl_display *display)
1963{
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05001964 struct wl_event_loop *loop;
Kristian Høgsbergd711d0c2011-01-14 17:28:21 -05001965 const char *extensions;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001966
Kristian Høgsbergf9212892008-10-11 18:40:23 -04001967 ec->wl_display = display;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04001968
Kristian Høgsberga8873122011-11-23 10:39:34 -05001969 if (!wl_display_add_global(display, &wl_compositor_interface,
1970 ec, compositor_bind))
1971 return -1;
Kristian Høgsbergee02ca62008-12-21 23:37:12 -05001972
Benjamin Franzke315b3dc2011-03-08 11:32:57 +01001973 ec->shm = wl_shm_init(display, &shm_callbacks);
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04001974
1975 ec->image_target_texture_2d =
1976 (void *) eglGetProcAddress("glEGLImageTargetTexture2DOES");
1977 ec->image_target_renderbuffer_storage = (void *)
1978 eglGetProcAddress("glEGLImageTargetRenderbufferStorageOES");
1979 ec->create_image = (void *) eglGetProcAddress("eglCreateImageKHR");
1980 ec->destroy_image = (void *) eglGetProcAddress("eglDestroyImageKHR");
1981 ec->bind_display =
1982 (void *) eglGetProcAddress("eglBindWaylandDisplayWL");
1983 ec->unbind_display =
1984 (void *) eglGetProcAddress("eglUnbindWaylandDisplayWL");
1985
1986 extensions = (const char *) glGetString(GL_EXTENSIONS);
1987 if (!strstr(extensions, "GL_EXT_texture_format_BGRA8888")) {
1988 fprintf(stderr,
1989 "GL_EXT_texture_format_BGRA8888 not available\n");
1990 return -1;
1991 }
1992
1993 extensions =
1994 (const char *) eglQueryString(ec->display, EGL_EXTENSIONS);
1995 if (strstr(extensions, "EGL_WL_bind_wayland_display"))
1996 ec->has_bind_display = 1;
1997 if (ec->has_bind_display)
1998 ec->bind_display(ec->display, ec->wl_display);
Kristian Høgsberg3d5bae02010-10-06 21:17:40 -04001999
Kristian Høgsberg201a9042008-12-10 00:40:50 -05002000 wl_list_init(&ec->surface_list);
Kristian Høgsberg81ce09a2008-12-31 16:18:42 -05002001 wl_list_init(&ec->input_device_list);
2002 wl_list_init(&ec->output_list);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002003 wl_list_init(&ec->binding_list);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002004 wl_list_init(&ec->animation_list);
Kristian Høgsbergd3ef7be2011-10-29 15:04:42 -04002005 wlsc_spring_init(&ec->fade.spring, 30.0, 1.0, 1.0);
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002006 ec->fade.animation.frame = fade_frame;
2007 wl_list_init(&ec->fade.animation.link);
Kristian Høgsberg3555d092011-04-11 13:58:13 -04002008
Pekka Paalanen35ce06d2012-01-03 11:39:13 +02002009 ec->screenshooter = screenshooter_create(ec);
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002010
Kristian Høgsberg47fe08a2011-10-28 12:26:06 -04002011 wlsc_data_device_manager_init(ec);
2012
Kristian Høgsbergfc783d42010-06-11 12:56:24 -04002013 glActiveTexture(GL_TEXTURE0);
Kristian Høgsberg7ffc4482011-04-22 14:23:51 -04002014
2015 if (wlsc_shader_init(&ec->texture_shader,
2016 vertex_shader, texture_fragment_shader) < 0)
Kristian Høgsberga9468212010-06-14 21:03:11 -04002017 return -1;
Kristian Høgsbergcce1aec2011-04-22 15:38:14 -04002018 if (init_solid_shader(&ec->solid_shader,
2019 ec->texture_shader.vertex_shader,
2020 solid_fragment_shader) < 0)
2021 return -1;
Kristian Høgsberg8d7ca6b2008-11-09 00:22:51 -05002022
Kristian Høgsbergfbdbbdc2008-11-28 17:06:06 -05002023 loop = wl_display_get_event_loop(ec->wl_display);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002024 ec->idle_source = wl_event_loop_add_timer(loop, idle_handler, ec);
Pekka Paalanen7296e792011-12-07 16:22:00 +02002025 wl_event_source_timer_update(ec->idle_source, ec->idle_time * 1000);
Kristian Høgsberge10a5d92011-04-22 14:01:18 -04002026
Kristian Høgsberg8da19ac2009-03-17 16:12:51 -04002027 wlsc_compositor_schedule_repaint(ec);
Kristian Høgsbergef7a9ca2008-10-11 21:21:39 -04002028
Kristian Høgsbergce5325d2010-06-14 11:54:00 -04002029 return 0;
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002030}
2031
Benjamin Franzkeb8263022011-08-30 11:32:47 +02002032WL_EXPORT void
Matt Roper361d2ad2011-08-29 13:52:23 -07002033wlsc_compositor_shutdown(struct wlsc_compositor *ec)
2034{
Tiago Vignattib303a1d2011-12-18 22:27:40 +02002035 struct wlsc_output *output, *next;
Matt Roper361d2ad2011-08-29 13:52:23 -07002036
Pekka Paalanend1591ae2012-01-02 16:06:56 +02002037 wl_event_source_remove(ec->idle_source);
2038
Pekka Paalanen35ce06d2012-01-03 11:39:13 +02002039 if (ec->screenshooter)
2040 screenshooter_destroy(ec->screenshooter);
2041
Matt Roper361d2ad2011-08-29 13:52:23 -07002042 /* Destroy all outputs associated with this compositor */
Tiago Vignattib303a1d2011-12-18 22:27:40 +02002043 wl_list_for_each_safe(output, next, &ec->output_list, link)
Matt Roper361d2ad2011-08-29 13:52:23 -07002044 output->destroy(output);
Pekka Paalanen4738f3b2012-01-02 15:47:07 +02002045
2046 wlsc_binding_list_destroy_all(&ec->binding_list);
Pekka Paalanend1591ae2012-01-02 16:06:56 +02002047
2048 wl_shm_finish(ec->shm);
2049
2050 wl_array_release(&ec->vertices);
2051 wl_array_release(&ec->indices);
Matt Roper361d2ad2011-08-29 13:52:23 -07002052}
2053
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002054static int on_term_signal(int signal_number, void *data)
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002055{
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002056 struct wl_display *display = data;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002057
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002058 fprintf(stderr, "caught signal %d\n", signal_number);
Kristian Høgsberg6bded3f2011-08-12 14:55:07 -04002059 wl_display_terminate(display);
Kristian Høgsbergb1868472011-04-22 12:27:57 -04002060
2061 return 1;
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002062}
2063
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002064static void *
2065load_module(const char *name, const char *entrypoint, void **handle)
2066{
2067 char path[PATH_MAX];
2068 void *module, *init;
2069
2070 if (name[0] != '/')
2071 snprintf(path, sizeof path, MODULEDIR "/%s", name);
2072 else
Benjamin Franzkeb7acce62011-05-06 23:19:22 +02002073 snprintf(path, sizeof path, "%s", name);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002074
2075 module = dlopen(path, RTLD_LAZY);
2076 if (!module) {
2077 fprintf(stderr,
2078 "failed to load module: %s\n", dlerror());
2079 return NULL;
2080 }
2081
2082 init = dlsym(module, entrypoint);
2083 if (!init) {
2084 fprintf(stderr,
2085 "failed to lookup init function: %s\n", dlerror());
2086 return NULL;
2087 }
2088
2089 return init;
2090}
2091
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002092int main(int argc, char *argv[])
2093{
2094 struct wl_display *display;
Kristian Høgsberg8e438622009-01-26 23:07:00 -05002095 struct wlsc_compositor *ec;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002096 struct wl_event_source *signals[4];
Kristian Høgsberg50dc6982010-12-01 16:43:56 -05002097 struct wl_event_loop *loop;
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002098 int o, xserver = 0;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002099 void *shell_module, *backend_module;
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04002100 int (*shell_init)(struct wlsc_compositor *ec);
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002101 struct wlsc_compositor
2102 *(*backend_init)(struct wl_display *display, char *options);
2103 char *backend = NULL;
2104 char *backend_options = "";
2105 char *shell = NULL;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002106 char *p;
Pekka Paalanen7296e792011-12-07 16:22:00 +02002107 int option_idle_time = 300;
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002108 int i;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002109
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002110 static const char opts[] = "B:b:o:S:i:s:x";
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002111 static const struct option longopts[ ] = {
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002112 { "backend", 1, NULL, 'B' },
2113 { "backend-options", 1, NULL, 'o' },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002114 { "socket", 1, NULL, 'S' },
2115 { "idle-time", 1, NULL, 'i' },
2116 { "shell", 1, NULL, 's' },
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002117 { "xserver", 0, NULL, 'x' },
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002118 { NULL, }
2119 };
Kristian Høgsbergd6531262008-12-12 11:06:18 -05002120
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002121 while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) {
2122 switch (o) {
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002123 case 'B':
2124 backend = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002125 break;
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002126 case 'o':
2127 backend_options = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002128 break;
2129 case 'S':
2130 option_socket_name = optarg;
2131 break;
2132 case 'i':
2133 option_idle_time = strtol(optarg, &p, 0);
2134 if (*p != '\0') {
2135 fprintf(stderr,
2136 "invalid idle time option: %s\n",
2137 optarg);
2138 exit(EXIT_FAILURE);
2139 }
2140 break;
2141 case 's':
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002142 shell = optarg;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002143 break;
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002144 case 'x':
2145 xserver = 1;
2146 break;
Kristian Høgsbergd34912c2011-05-02 10:36:04 -04002147 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04002148 }
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002149
2150 display = wl_display_create();
2151
Tiago Vignatti2116b892011-08-08 05:52:59 -07002152 loop = wl_display_get_event_loop(display);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002153 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
2154 display);
2155 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
2156 display);
2157 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
2158 display);
Tiago Vignatti2116b892011-08-08 05:52:59 -07002159
2160 wl_list_init(&child_process_list);
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002161 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
2162 NULL);
Kristian Høgsberga9410222011-01-14 17:22:35 -05002163
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002164 if (!backend) {
2165 if (getenv("WAYLAND_DISPLAY"))
2166 backend = "wayland-backend.so";
2167 else if (getenv("DISPLAY"))
2168 backend = "x11-backend.so";
2169 else if (getenv("OPENWFD"))
2170 backend = "openwfd-backend.so";
2171 else
2172 backend = "drm-backend.so";
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04002173 }
2174
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002175 if (!shell)
2176 shell = "desktop-shell.so";
Kristian Høgsberga9410222011-01-14 17:22:35 -05002177
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002178 backend_init = load_module(backend, "backend_init", &backend_module);
2179 if (!backend_init)
2180 exit(EXIT_FAILURE);
Kristian Høgsberga9410222011-01-14 17:22:35 -05002181
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002182 shell_init = load_module(shell, "shell_init", &shell_module);
2183 if (!shell_init)
2184 exit(EXIT_FAILURE);
Benjamin Franzke5d007092011-04-04 00:30:25 +02002185
Kristian Høgsberg1c562182011-05-02 22:09:20 -04002186 ec = backend_init(display, backend_options);
Kristian Høgsberg841883b2008-12-05 11:19:56 -05002187 if (ec == NULL) {
2188 fprintf(stderr, "failed to create compositor\n");
2189 exit(EXIT_FAILURE);
2190 }
Kristian Høgsberg61a82512010-10-26 11:26:44 -04002191
Pekka Paalanen7296e792011-12-07 16:22:00 +02002192 ec->option_idle_time = option_idle_time;
2193 ec->idle_time = option_idle_time;
2194
Kristian Høgsberg02ec0a52011-04-23 13:04:11 -04002195 if (shell_init(ec) < 0)
2196 exit(EXIT_FAILURE);
2197
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002198 if (xserver)
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002199 wlsc_xserver_init(ec);
Kristian Høgsberg27da5382011-06-21 17:32:25 -04002200
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05002201 if (wl_display_add_socket(display, option_socket_name)) {
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002202 fprintf(stderr, "failed to add socket: %m\n");
2203 exit(EXIT_FAILURE);
2204 }
2205
2206 wl_display_run(display);
2207
Pekka Paalanen0135abe2012-01-03 10:01:20 +02002208 /* prevent further rendering while shutting down */
2209 ec->state = WLSC_COMPOSITOR_SLEEPING;
2210
Kristian Høgsberg3cad4362011-07-15 21:09:24 -04002211 if (xserver)
2212 wlsc_xserver_destroy(ec);
2213
Pekka Paalanen3c647232011-12-22 13:43:43 +02002214 ec->shell->destroy(ec->shell);
2215
Kristian Høgsbergb5819dc2011-04-25 15:08:20 -04002216 if (ec->has_bind_display)
2217 ec->unbind_display(ec->display, display);
Kristian Høgsberg2bb3ebe2010-12-01 15:36:20 -05002218
Pekka Paalanen51c769f2012-01-02 16:03:26 +02002219 for (i = ARRAY_LENGTH(signals); i;)
2220 wl_event_source_remove(signals[--i]);
2221
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002222 ec->destroy(ec);
Tiago Vignatti9e2be082011-12-19 00:04:46 +02002223 wl_display_destroy(display);
Kristian Høgsbergcaa64422010-12-01 16:52:15 -05002224
Kristian Høgsberg122912c2008-12-05 11:13:50 -05002225 return 0;
Kristian Høgsberg16eb6752008-10-08 22:51:32 -04002226}